From 702cd4c5a155f195dd467e9f8b9975e70405a754 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20M=2E=20Wo=C5=BAniak?= Date: Tue, 3 Nov 2026 23:48:37 +0100 Subject: [PATCH 1/3] test(abr): read tool blend mode and opacity from MdSl Fails until parse_tool_options reads the nested MdSl object. --- crates/abr/src/descriptor.rs | 78 ++++++++++++++++++++++++++++++++ crates/abr/tests/corpus_smoke.rs | 74 ++++++++++++++++++++++++++++++ 2 files changed, 152 insertions(+) diff --git a/crates/abr/src/descriptor.rs b/crates/abr/src/descriptor.rs index d03cc44..f1b73d1 100644 --- a/crates/abr/src/descriptor.rs +++ b/crates/abr/src/descriptor.rs @@ -1337,6 +1337,56 @@ mod tests { buf } + fn build_mdsl_desc_block(layer_key: &[u8; 4], top_level: bool) -> Vec { + let mut buf = Vec::new(); + + buf.write_u32::(16).unwrap(); + buf.write_u32::(1).unwrap(); + buf.write_u16::(0).unwrap(); + buf.write_u32::(0).unwrap(); + buf.extend_from_slice(b"null"); + buf.write_u32::(1).unwrap(); + + buf.write_u32::(0).unwrap(); + buf.extend_from_slice(b"Brsh"); + buf.extend_from_slice(b"VlLs"); + buf.write_u32::(1).unwrap(); + + buf.extend_from_slice(b"Objc"); + buf.write_u32::(1).unwrap(); + buf.write_u16::(0).unwrap(); + buf.write_u32::(11).unwrap(); + buf.extend_from_slice(b"brushPreset"); + buf.write_u32::(2).unwrap(); + + write_key(&mut buf, b"toolOptions"); + buf.extend_from_slice(b"Objc"); + buf.write_u32::(1).unwrap(); + buf.write_u16::(0).unwrap(); + write_key(&mut buf, b"PbTl"); + buf.write_u32::(if top_level { 4 } else { 2 }) + .unwrap(); + write_long(&mut buf, b"flow", 50); + write_key(&mut buf, b"MdSl"); + buf.extend_from_slice(b"Objc"); + buf.write_u32::(1).unwrap(); + buf.write_u16::(0).unwrap(); + write_key(&mut buf, b"MdSC"); + buf.write_u32::(4).unwrap(); + write_long(&mut buf, b"Sgnt", i32::from_be_bytes(*b"8BIM")); + write_long(&mut buf, b"Ky ", i32::from_be_bytes(*layer_key)); + write_long(&mut buf, b"Opct", 35); + write_bool(&mut buf, b"Clpp", false); + if top_level { + write_enum(&mut buf, b"Md ", b"BlnM", b"Scrn"); + write_long(&mut buf, b"Opct", 80); + } + + write_text(&mut buf, b"Nm ", "Oval Multiply"); + + buf + } + fn mixer_tool_options() -> crate::ToolOptions { crate::ToolOptions { tool: "MixB".to_string(), @@ -1904,6 +1954,34 @@ mod tests { ); } + fn mdsl_tool_options(layer_key: &[u8; 4], top_level: bool) -> crate::ToolOptions { + let infos = extract_all_brush_info(&build_mdsl_desc_block(layer_key, top_level)); + assert_eq!(infos.len(), 1); + infos[0].descriptor.tool_options.clone().unwrap() + } + + #[test] + fn mdsl_supplies_blend_mode_and_opacity() { + let options = mdsl_tool_options(b"mul ", false); + assert_eq!(options.blend_mode.as_deref(), Some("Mltp")); + assert_eq!(options.opacity_pct, Some(35)); + assert_eq!(options.flow_pct, Some(50)); + } + + #[test] + fn top_level_md_and_opct_win_over_mdsl() { + let options = mdsl_tool_options(b"mul ", true); + assert_eq!(options.blend_mode.as_deref(), Some("Scrn")); + assert_eq!(options.opacity_pct, Some(80)); + } + + #[test] + fn unknown_mdsl_layer_key_reads_raw() { + let options = mdsl_tool_options(b"zzz ", false); + assert_eq!(options.blend_mode.as_deref(), Some("zzz ")); + assert_eq!(options.opacity_pct, Some(35)); + } + #[test] fn opacity_jitter_is_parsed() { let data = build_dynamics_desc_block("Paint", false, false, true, 0, 0); diff --git a/crates/abr/tests/corpus_smoke.rs b/crates/abr/tests/corpus_smoke.rs index 3d3279c..4a7b881 100644 --- a/crates/abr/tests/corpus_smoke.rs +++ b/crates/abr/tests/corpus_smoke.rs @@ -463,3 +463,77 @@ fn corpus_sets_a_non_default_tilt_scale_on_size_on_pen_tilt() { "no corpus preset with Size on Pen Tilt reads a tilt_scale_pct other than 200 %" ); } + +fn tool_options_items( + items: &[brushkit_abr::dump::DumpItem], +) -> Option<&[brushkit_abr::dump::DumpItem]> { + items.iter().find_map(|item| match &item.value { + brushkit_abr::dump::DumpValue::Objc { items, .. } if item.key == "toolOptions" => { + Some(items.as_slice()) + } + _ => None, + }) +} + +/// `toolOptions/MdSl/Opct` of a preset that stores its blend mode and opacity +/// only in `MdSl`. +fn mdsl_only_opacity(items: &[brushkit_abr::dump::DumpItem]) -> Option { + let options = tool_options_items(items)?; + if options.iter().any(|i| i.key == "Md " || i.key == "Opct") { + return None; + } + options.iter().find_map(|item| match &item.value { + brushkit_abr::dump::DumpValue::Objc { items, .. } if item.key == "MdSl" => { + items.iter().find_map(|i| match i.value { + brushkit_abr::dump::DumpValue::Long(v) if i.key == "Opct" => Some(v), + _ => None, + }) + } + _ => None, + }) +} + +#[test] +fn every_corpus_mdsl_preset_reads_its_blend_mode_and_opacity() { + let Some((root, files)) = corpus() else { + println!("skip: BRUSHKIT_CORPUS_DIR unset"); + return; + }; + let mut checked = 0; + for path in &files { + let bytes = std::fs::read(path).expect("corpus file is readable"); + let name = path.strip_prefix(&root).unwrap_or(path).display(); + let pack = brushkit_abr::parse_abr(&bytes).unwrap_or_else(|e| panic!("{name}: {e}")); + let presets = pack + .raw_desc_block + .as_deref() + .map(|desc| brushkit_abr::dump::dump_descriptors(desc).presets) + .unwrap_or_default(); + let descriptors = pack + .brushes + .iter() + .map(|b| (&b.descriptor, b.preset_index)) + .chain( + pack.computed_presets + .iter() + .map(|p| (&p.descriptor, p.preset_index)), + ); + for (d, preset_index) in descriptors { + let Some(opacity) = preset_index + .and_then(|pi| presets.get(pi)) + .and_then(|p| mdsl_only_opacity(&p.items)) + else { + continue; + }; + let options = d.tool_options.as_ref().expect("toolOptions is parsed"); + assert_eq!(options.opacity_pct, Some(opacity), "{name}"); + assert!(options.blend_mode.is_some(), "{name}: no blend_mode"); + checked += 1; + } + } + println!("{checked} preset(s) with MdSl only"); + assert!( + checked > 0, + "no corpus preset stores its blend mode only in MdSl" + ); +} From b5f842c7570fc86e027b7bfb04edea48c5edbdce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20M=2E=20Wo=C5=BAniak?= Date: Tue, 3 Nov 2026 23:51:18 +0100 Subject: [PATCH 2/3] fix(abr): read tool blend mode and opacity from MdSl A preset can store its tool blend mode and opacity in toolOptions/MdSl instead of the top-level Md and Opct keys. Map the MdSl layer key to its BlnM value id, read MdSl/Opct, and keep the top-level keys first. --- crates/abr/src/descriptor.rs | 79 ++++++++++++++++++++++++++++++++++++ crates/abr/src/lib.rs | 7 +++- 2 files changed, 84 insertions(+), 2 deletions(-) diff --git a/crates/abr/src/descriptor.rs b/crates/abr/src/descriptor.rs index f1b73d1..4e875bf 100644 --- a/crates/abr/src/descriptor.rs +++ b/crates/abr/src/descriptor.rs @@ -809,6 +809,79 @@ fn parse_txtr(cursor: &mut Cursor<&[u8]>) -> io::Result { Ok(Txtr { name, id }) } +/// Layer blend keys (`MdSl/Ky `) and the `BlnM` value id of the same mode. +const LAYER_BLEND_MODES: [([u8; 4], &str); 27] = [ + (*b"norm", "Nrml"), + (*b"diss", "Dslv"), + (*b"dark", "Drkn"), + (*b"mul ", "Mltp"), + (*b"idiv", "CBrn"), + (*b"lbrn", "linearBurn"), + (*b"dkCl", "darkerColor"), + (*b"lite", "Lghn"), + (*b"scrn", "Scrn"), + (*b"div ", "CDdg"), + (*b"lddg", "linearDodge"), + (*b"lgCl", "lighterColor"), + (*b"over", "Ovrl"), + (*b"sLit", "SftL"), + (*b"hLit", "HrdL"), + (*b"vLit", "vividLight"), + (*b"lLit", "linearLight"), + (*b"pLit", "pinLight"), + (*b"hMix", "hardMix"), + (*b"diff", "Dfrn"), + (*b"smud", "Xclu"), + (*b"fsub", "blendSubtraction"), + (*b"fdiv", "blendDivide"), + (*b"hue ", "H "), + (*b"sat ", "Strt"), + (*b"colr", "Clr "), + (*b"lum ", "Lmns"), +]; + +/// Parsed contents of the `MdSl` object (class `MdSC`) inside `toolOptions`. +struct MdSl { + blend_mode: Option, + opacity_pct: Option, +} + +fn parse_mdsl(cursor: &mut Cursor<&[u8]>) -> io::Result { + let _class_name = read_unicode_string(cursor)?; + let _class_id = read_id(cursor)?; + let item_count = cursor.read_u32::()?; + + let mut mdsl = MdSl { + blend_mode: None, + opacity_pct: None, + }; + for _ in 0..item_count { + let key = read_id(cursor)?; + let type_tag = read_type_tag(cursor)?; + match (key.as_str(), type_tag.as_str()) { + ("Ky ", "long") => { + let layer_key = cursor.read_i32::()?.to_be_bytes(); + mdsl.blend_mode = Some( + LAYER_BLEND_MODES + .iter() + .find(|(k, _)| *k == layer_key) + .map_or_else( + || String::from_utf8_lossy(&layer_key).into_owned(), + |(_, id)| id.to_string(), + ), + ); + } + ("Opct", "long") => mdsl.opacity_pct = Some(cursor.read_i32::()?), + _ => { + if skip_descriptor_value(cursor, &type_tag, 0).is_err() { + break; + } + } + } + } + Ok(mdsl) +} + fn parse_tool_options(cursor: &mut Cursor<&[u8]>) -> io::Result { let _class_name = read_unicode_string(cursor)?; let mut options = crate::ToolOptions { @@ -816,6 +889,7 @@ fn parse_tool_options(cursor: &mut Cursor<&[u8]>) -> io::Result()?; + let mut mdsl = None; for _ in 0..item_count { let key = read_id(cursor)?; @@ -834,6 +908,7 @@ fn parse_tool_options(cursor: &mut Cursor<&[u8]>) -> io::Result options.wetness_pct = Some(cursor.read_f64::()?), ("dryness", "doub") => options.dryness_pct = Some(cursor.read_f64::()?), ("mix", "doub") => options.mix_pct = Some(cursor.read_f64::()?), + ("MdSl", "Objc") => mdsl = Some(parse_mdsl(cursor)?), _ => { if skip_descriptor_value(cursor, &type_tag, 0).is_err() { break; @@ -841,6 +916,10 @@ fn parse_tool_options(cursor: &mut Cursor<&[u8]>) -> io::Result, /// `toolOptions/flow` (`long`) — flow percent. pub flow_pct: Option, /// `toolOptions/Md ` (`enum` `BlnM`, key = "Md" + two spaces) — the raw - /// blend-mode value id (e.g. "Nrml"). + /// blend-mode value id (e.g. "Nrml"). Without it, the `BlnM` value id of + /// the layer blend key in `toolOptions/MdSl/Ky ` (`long`, e.g. `mul ` → + /// "Mltp"), or the raw four-byte key when it has no known `BlnM` id. pub blend_mode: Option, /// `toolOptions/smoothing` (`bool`). pub smoothing: Option, From 875678c9dac38f272cc41fa293da2a991828c533 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20M=2E=20Wo=C5=BAniak?= Date: Wed, 4 Nov 2026 00:00:04 +0100 Subject: [PATCH 3/3] fix(abr): keep the preset when its MdSl is malformed A malformed MdSl ends the toolOptions read as the skip did before, instead of dropping the preset. Tests cover both key orders for top-level precedence, and the corpus test checks the layer key maps to a BlnM id. --- crates/abr/src/descriptor.rs | 113 +++++++++++++++++++++---------- crates/abr/tests/corpus_smoke.rs | 38 +++++++---- 2 files changed, 100 insertions(+), 51 deletions(-) diff --git a/crates/abr/src/descriptor.rs b/crates/abr/src/descriptor.rs index 4e875bf..71161ed 100644 --- a/crates/abr/src/descriptor.rs +++ b/crates/abr/src/descriptor.rs @@ -809,8 +809,7 @@ fn parse_txtr(cursor: &mut Cursor<&[u8]>) -> io::Result { Ok(Txtr { name, id }) } -/// Layer blend keys (`MdSl/Ky `) and the `BlnM` value id of the same mode. -const LAYER_BLEND_MODES: [([u8; 4], &str); 27] = [ +const LAYER_KEY_TO_BLNM_ID: [([u8; 4], &str); 27] = [ (*b"norm", "Nrml"), (*b"diss", "Dslv"), (*b"dark", "Drkn"), @@ -840,7 +839,6 @@ const LAYER_BLEND_MODES: [([u8; 4], &str); 27] = [ (*b"lum ", "Lmns"), ]; -/// Parsed contents of the `MdSl` object (class `MdSC`) inside `toolOptions`. struct MdSl { blend_mode: Option, opacity_pct: Option, @@ -862,7 +860,7 @@ fn parse_mdsl(cursor: &mut Cursor<&[u8]>) -> io::Result { ("Ky ", "long") => { let layer_key = cursor.read_i32::()?.to_be_bytes(); mdsl.blend_mode = Some( - LAYER_BLEND_MODES + LAYER_KEY_TO_BLNM_ID .iter() .find(|(k, _)| *k == layer_key) .map_or_else( @@ -872,11 +870,7 @@ fn parse_mdsl(cursor: &mut Cursor<&[u8]>) -> io::Result { ); } ("Opct", "long") => mdsl.opacity_pct = Some(cursor.read_i32::()?), - _ => { - if skip_descriptor_value(cursor, &type_tag, 0).is_err() { - break; - } - } + _ => skip_descriptor_value(cursor, &type_tag, 0)?, } } Ok(mdsl) @@ -908,7 +902,10 @@ fn parse_tool_options(cursor: &mut Cursor<&[u8]>) -> io::Result options.wetness_pct = Some(cursor.read_f64::()?), ("dryness", "doub") => options.dryness_pct = Some(cursor.read_f64::()?), ("mix", "doub") => options.mix_pct = Some(cursor.read_f64::()?), - ("MdSl", "Objc") => mdsl = Some(parse_mdsl(cursor)?), + ("MdSl", "Objc") => match parse_mdsl(cursor) { + Ok(parsed) => mdsl = Some(parsed), + Err(_) => break, + }, _ => { if skip_descriptor_value(cursor, &type_tag, 0).is_err() { break; @@ -1416,7 +1413,15 @@ mod tests { buf } - fn build_mdsl_desc_block(layer_key: &[u8; 4], top_level: bool) -> Vec { + #[derive(Clone, Copy)] + enum ToolItem { + Flow, + MdSl(&'static [u8; 4]), + MalformedMdSl, + TopLevelModeAndOpacity, + } + + fn build_mdsl_desc_block(items: &[ToolItem]) -> Vec { let mut buf = Vec::new(); buf.write_u32::(16).unwrap(); @@ -1438,31 +1443,54 @@ mod tests { buf.extend_from_slice(b"brushPreset"); buf.write_u32::(2).unwrap(); + write_text(&mut buf, b"Nm ", "Oval Multiply"); + write_key(&mut buf, b"toolOptions"); buf.extend_from_slice(b"Objc"); buf.write_u32::(1).unwrap(); buf.write_u16::(0).unwrap(); write_key(&mut buf, b"PbTl"); - buf.write_u32::(if top_level { 4 } else { 2 }) - .unwrap(); - write_long(&mut buf, b"flow", 50); - write_key(&mut buf, b"MdSl"); - buf.extend_from_slice(b"Objc"); - buf.write_u32::(1).unwrap(); - buf.write_u16::(0).unwrap(); - write_key(&mut buf, b"MdSC"); - buf.write_u32::(4).unwrap(); - write_long(&mut buf, b"Sgnt", i32::from_be_bytes(*b"8BIM")); - write_long(&mut buf, b"Ky ", i32::from_be_bytes(*layer_key)); - write_long(&mut buf, b"Opct", 35); - write_bool(&mut buf, b"Clpp", false); - if top_level { - write_enum(&mut buf, b"Md ", b"BlnM", b"Scrn"); - write_long(&mut buf, b"Opct", 80); + let count = items + .iter() + .map(|i| match i { + ToolItem::TopLevelModeAndOpacity => 2, + _ => 1, + }) + .sum::(); + buf.write_u32::(count).unwrap(); + for item in items { + match item { + ToolItem::Flow => write_long(&mut buf, b"flow", 50), + ToolItem::MdSl(layer_key) => { + write_key(&mut buf, b"MdSl"); + buf.extend_from_slice(b"Objc"); + buf.write_u32::(1).unwrap(); + buf.write_u16::(0).unwrap(); + write_key(&mut buf, b"MdSC"); + buf.write_u32::(4).unwrap(); + write_long(&mut buf, b"Sgnt", i32::from_be_bytes(*b"8BIM")); + write_long(&mut buf, b"Ky ", i32::from_be_bytes(**layer_key)); + write_long(&mut buf, b"Opct", 35); + write_bool(&mut buf, b"Clpp", false); + } + ToolItem::MalformedMdSl => { + write_key(&mut buf, b"MdSl"); + buf.extend_from_slice(b"Objc"); + buf.write_u32::(1).unwrap(); + buf.write_u16::(0).unwrap(); + write_key(&mut buf, b"MdSC"); + buf.write_u32::(2).unwrap(); + write_long(&mut buf, b"Ky ", i32::from_be_bytes(*b"mul ")); + write_key(&mut buf, b"Clpp"); + buf.extend_from_slice(b"zzzz"); + } + ToolItem::TopLevelModeAndOpacity => { + write_enum(&mut buf, b"Md ", b"BlnM", b"Scrn"); + write_long(&mut buf, b"Opct", 80); + } + } } - write_text(&mut buf, b"Nm ", "Oval Multiply"); - buf } @@ -2033,34 +2061,45 @@ mod tests { ); } - fn mdsl_tool_options(layer_key: &[u8; 4], top_level: bool) -> crate::ToolOptions { - let infos = extract_all_brush_info(&build_mdsl_desc_block(layer_key, top_level)); + fn mdsl_tool_options(items: &[ToolItem]) -> crate::ToolOptions { + let infos = extract_all_brush_info(&build_mdsl_desc_block(items)); assert_eq!(infos.len(), 1); infos[0].descriptor.tool_options.clone().unwrap() } #[test] fn mdsl_supplies_blend_mode_and_opacity() { - let options = mdsl_tool_options(b"mul ", false); + let options = mdsl_tool_options(&[ToolItem::Flow, ToolItem::MdSl(b"mul ")]); assert_eq!(options.blend_mode.as_deref(), Some("Mltp")); assert_eq!(options.opacity_pct, Some(35)); assert_eq!(options.flow_pct, Some(50)); } #[test] - fn top_level_md_and_opct_win_over_mdsl() { - let options = mdsl_tool_options(b"mul ", true); - assert_eq!(options.blend_mode.as_deref(), Some("Scrn")); - assert_eq!(options.opacity_pct, Some(80)); + fn top_level_md_and_opct_win_over_mdsl_in_either_order() { + let mdsl = ToolItem::MdSl(b"mul "); + let top = ToolItem::TopLevelModeAndOpacity; + for items in [[mdsl, top], [top, mdsl]] { + let options = mdsl_tool_options(&items); + assert_eq!(options.blend_mode.as_deref(), Some("Scrn")); + assert_eq!(options.opacity_pct, Some(80)); + } } #[test] fn unknown_mdsl_layer_key_reads_raw() { - let options = mdsl_tool_options(b"zzz ", false); + let options = mdsl_tool_options(&[ToolItem::MdSl(b"zzz ")]); assert_eq!(options.blend_mode.as_deref(), Some("zzz ")); assert_eq!(options.opacity_pct, Some(35)); } + #[test] + fn malformed_mdsl_keeps_the_preset_and_earlier_tool_options() { + let options = mdsl_tool_options(&[ToolItem::Flow, ToolItem::MalformedMdSl]); + assert_eq!(options.flow_pct, Some(50)); + assert_eq!(options.blend_mode, None); + } + #[test] fn opacity_jitter_is_parsed() { let data = build_dynamics_desc_block("Paint", false, false, true, 0, 0); diff --git a/crates/abr/tests/corpus_smoke.rs b/crates/abr/tests/corpus_smoke.rs index 4a7b881..b70adf8 100644 --- a/crates/abr/tests/corpus_smoke.rs +++ b/crates/abr/tests/corpus_smoke.rs @@ -475,22 +475,25 @@ fn tool_options_items( }) } -/// `toolOptions/MdSl/Opct` of a preset that stores its blend mode and opacity -/// only in `MdSl`. -fn mdsl_only_opacity(items: &[brushkit_abr::dump::DumpItem]) -> Option { +fn mdsl_only_layer_key_and_opacity( + items: &[brushkit_abr::dump::DumpItem], +) -> Option<(String, i32)> { let options = tool_options_items(items)?; if options.iter().any(|i| i.key == "Md " || i.key == "Opct") { return None; } - options.iter().find_map(|item| match &item.value { - brushkit_abr::dump::DumpValue::Objc { items, .. } if item.key == "MdSl" => { - items.iter().find_map(|i| match i.value { - brushkit_abr::dump::DumpValue::Long(v) if i.key == "Opct" => Some(v), - _ => None, - }) - } + let mdsl = options.iter().find_map(|item| match &item.value { + brushkit_abr::dump::DumpValue::Objc { items, .. } if item.key == "MdSl" => Some(items), _ => None, - }) + })?; + let long = |key: &str| { + mdsl.iter().find_map(|i| match i.value { + brushkit_abr::dump::DumpValue::Long(v) if i.key == key => Some(v), + _ => None, + }) + }; + let layer_key = String::from_utf8_lossy(&long("Ky ")?.to_be_bytes()).into_owned(); + Some((layer_key, long("Opct")?)) } #[test] @@ -519,15 +522,22 @@ fn every_corpus_mdsl_preset_reads_its_blend_mode_and_opacity() { .map(|p| (&p.descriptor, p.preset_index)), ); for (d, preset_index) in descriptors { - let Some(opacity) = preset_index + let Some((layer_key, opacity)) = preset_index .and_then(|pi| presets.get(pi)) - .and_then(|p| mdsl_only_opacity(&p.items)) + .and_then(|p| mdsl_only_layer_key_and_opacity(&p.items)) else { continue; }; let options = d.tool_options.as_ref().expect("toolOptions is parsed"); assert_eq!(options.opacity_pct, Some(opacity), "{name}"); - assert!(options.blend_mode.is_some(), "{name}: no blend_mode"); + let blend_mode = options.blend_mode.as_deref(); + assert!( + blend_mode.is_some_and(|m| m != layer_key), + "{name}: layer key {layer_key:?} read as {blend_mode:?}, not a BlnM id" + ); + if layer_key == "mul " { + assert_eq!(blend_mode, Some("Mltp"), "{name}"); + } checked += 1; } }