diff --git a/crates/engine/src/cmd/shape.rs b/crates/engine/src/cmd/shape.rs index 9ae6ae90..f2a5da07 100644 --- a/crates/engine/src/cmd/shape.rs +++ b/crates/engine/src/cmd/shape.rs @@ -5,7 +5,7 @@ use std::collections::HashMap; use deckcraft_color::{ColorTransform, Rgba, SchemeSlot}; use deckcraft_model::style::{Dash, Glow, Gradient, GradientShape, GradientStop, LineEnd, PatternFill, PictureFill, PictureMode, Reflection, Shadow}; -use deckcraft_model::{ColorRef, Effects, Fill, Geom, Line, ShapeStyle}; +use deckcraft_model::{ColorRef, Effects, Fill, Geom, Line, ShapeId, ShapeStyle}; use serde_json::{Value, json}; use super::{ @@ -556,81 +556,102 @@ fn edit_group_appearance(s: &mut Session, p: &Value, cmd: &str, f: impl Fn(&mut edit_shapes(s, p, cmd, |sh| apply(sh, 0, &f)) } -fn fill(s: &mut Session, p: &Value) -> Result { - let new_fill: Option> = if bool_or(p, "reset", false) { - Some(None) - } else if bool_or(p, "none", false) { - Some(Some(Fill::None)) - } else if let Some(c) = color_param(p, "color") { - Some(Some(Fill::solid(c))) - } else if let Some(g) = p.get("gradient") { - Some(Some(Fill::Gradient( - gradient_param(g).ok_or_else(|| bad("shape.fill", "gradient needs at least two `stops`: [[0, \"#fff\"], [1, \"#000\"]]"))?, - ))) - } else if let Some(pt) = p.get("pattern") { - Some(Some(Fill::Pattern(PatternFill { +/// The fill a `shape.fill` request sets: `Some(None)` clears it, `Some(Some(_))` sets it, and `None` +/// leaves it as it is. +fn requested_fill(s: &mut Session, p: &Value) -> Result>> { + if bool_or(p, "reset", false) { + return Ok(Some(None)); + } + if bool_or(p, "none", false) { + return Ok(Some(Some(Fill::None))); + } + if let Some(c) = color_param(p, "color") { + return Ok(Some(Some(Fill::solid(c)))); + } + if let Some(g) = p.get("gradient") { + let gradient = gradient_param(g).ok_or_else(|| bad("shape.fill", "gradient needs at least two `stops`: [[0, \"#fff\"], [1, \"#000\"]]"))?; + return Ok(Some(Some(Fill::Gradient(gradient)))); + } + if let Some(pt) = p.get("pattern") { + return Ok(Some(Some(Fill::Pattern(PatternFill { preset: pt.get("preset").and_then(Value::as_str).unwrap_or("pct50").to_string(), fg: pt.get("fg").and_then(color_value).unwrap_or(ColorRef::scheme(SchemeSlot::Accent1)), bg: pt.get("bg").and_then(color_value).unwrap_or(ColorRef::scheme(SchemeSlot::Bg1)), - }))) - } else if p.get("picture").is_some() { + })))); + } + if p.get("picture").is_some() { let (name, bytes) = super::insert::media_bytes(&with_param(p, "data", p.get("picture").cloned().unwrap_or_default()), "shape.fill")?; let ct = super::insert::content_type(&name, &bytes); let media = s.edit(|doc, _| doc.add_media(&name, ct, bytes).ok_or_else(|| bad("shape.fill", NO_ID_SPACE)))?; - Some(Some(Fill::Picture(PictureFill { media, ..Default::default() }))) - } else { - None - }; + return Ok(Some(Some(Fill::Picture(PictureFill { media, ..Default::default() })))); + } + Ok(None) +} + +/// The effective fill of each targeted shape, for a transparency change on an inherited (style) fill. +fn inherited_fills(s: &Session, p: &Value) -> Result>> { + let st = s.doc()?; + let ctx = super::text::ctx_for(&st.doc, &st.selection); + let mut fills = HashMap::new(); + for id in targets(s, p)? { + if let Some(sh) = st.shape(id) { + deckcraft_model::walk(std::slice::from_ref(sh), &mut |sh, _| { + let fill = ctx.as_ref().and_then(|c| { + let (f, ph) = deckcraft_model::resolve::fill(c, sh); + f.map(|f| match f { + Fill::Solid { color } => Fill::solid(ColorRef::rgb(c.color(&color, ph))), + other => other, + }) + }); + fills.insert(sh.id, fill); + }); + } + } + Ok(fills) +} + +/// Applies a `shape.fill` request to one shape: the fill, then its picture options, then transparency. +fn apply_fill( + sh: &mut deckcraft_model::Shape, + new_fill: Option<&Option>, + pic_props: Option<&Value>, + transparency: Option, + inherited: &HashMap>, +) -> Result<()> { + if let Some(f) = new_fill { + sh.fill.clone_from(f); + } + if let (Some(pp), Some(Fill::Picture(pf))) = (pic_props, sh.fill.as_mut()) { + picture_props(pf, pp); + } + if let (Some(t), Some(Fill::Picture(pf))) = (transparency, sh.fill.as_mut()) { + let a = 1.0 - t.clamp(0.0, 1.0); + pf.alpha = (a < 1.0).then_some(a); + return Ok(()); + } + if let Some(t) = transparency { + let base = sh.fill.clone().or_else(|| inherited.get(&sh.id).cloned().flatten()); + if let Some(Fill::Solid { mut color }) = base { + color.mods.retain(|m| !matches!(m, ColorTransform::Alpha(_))); + if t > 0.0 { + color.mods.push(ColorTransform::Alpha(((1.0 - t.clamp(0.0, 1.0)) * 100_000.0).round() as i32)); + } + sh.fill = Some(Fill::Solid { color }); + } + } + Ok(()) +} + +fn fill(s: &mut Session, p: &Value) -> Result { + let new_fill = requested_fill(s, p)?; let transparency = f64_param(p, "transparency"); let pic_props = p.get("pictureProps").filter(|v| v.is_object()); if new_fill.is_none() && transparency.is_none() && pic_props.is_none() { return Err(bad("shape.fill", "give `color`, `none`, `gradient`, `pattern`, `picture`, `pictureProps`, `transparency` or `reset`")); } // Transparency on an inherited (style) fill needs the effective colour. - let st = s.doc()?; - let ctx_fill = { - let ctx = super::text::ctx_for(&st.doc, &st.selection); - let mut fills = HashMap::new(); - for id in targets(s, p)? { - if let Some(sh) = st.shape(id) { - deckcraft_model::walk(std::slice::from_ref(sh), &mut |sh, _| { - let fill = ctx.as_ref().and_then(|c| { - let (f, ph) = deckcraft_model::resolve::fill(c, sh); - f.map(|f| match f { - Fill::Solid { color } => Fill::solid(ColorRef::rgb(c.color(&color, ph))), - other => other, - }) - }); - fills.insert(sh.id, fill); - }); - } - } - fills - }; - edit_group_appearance(s, p, "shape.fill", |sh| { - if let Some(f) = &new_fill { - sh.fill.clone_from(f); - } - if let (Some(pp), Some(Fill::Picture(pf))) = (pic_props, sh.fill.as_mut()) { - picture_props(pf, pp); - } - if let (Some(t), Some(Fill::Picture(pf))) = (transparency, sh.fill.as_mut()) { - let a = 1.0 - t.clamp(0.0, 1.0); - pf.alpha = (a < 1.0).then_some(a); - return Ok(()); - } - if let Some(t) = transparency { - let base = sh.fill.clone().or_else(|| ctx_fill.get(&sh.id).cloned().flatten()); - if let Some(Fill::Solid { mut color }) = base { - color.mods.retain(|m| !matches!(m, ColorTransform::Alpha(_))); - if t > 0.0 { - color.mods.push(ColorTransform::Alpha(((1.0 - t.clamp(0.0, 1.0)) * 100_000.0).round() as i32)); - } - sh.fill = Some(Fill::Solid { color }); - } - } - Ok(()) - }) + let inherited = inherited_fills(s, p)?; + edit_group_appearance(s, p, "shape.fill", |sh| apply_fill(sh, new_fill.as_ref(), pic_props, transparency, &inherited)) } /// Applies Format Shape ▸ Picture or texture fill options to a picture fill. diff --git a/crates/h264/src/dpb.rs b/crates/h264/src/dpb.rs index a74799d9..dfe81ed3 100644 --- a/crates/h264/src/dpb.rs +++ b/crates/h264/src/dpb.rs @@ -204,6 +204,48 @@ impl Dpb { entry_lists } + /// picNumLXNoWrap (8-34, 8-35) of a short-term modification from the predictor `pred`, and the + /// picNum it selects. + fn short_term_pic_nums(pred: i32, idc: u32, value: u32, curr_pic_num: i32, max_pic_num: i32) -> (i32, i32) { + let d = value as i32 + 1; + let no_wrap = if idc == 0 { + if pred - d < 0 { pred - d + max_pic_num } else { pred - d } + } else if pred + d >= max_pic_num { + pred + d - max_pic_num + } else { + pred + d + }; + let pn = if no_wrap > curr_pic_num { no_wrap - max_pic_num } else { no_wrap }; + (no_wrap, pn) + } + + /// Puts `target` at `ref_idx` and shifts the rest of the list up, then drops the later entries + /// that repeat it (8.2.4.3.1, 8.2.4.3.2) and keeps the list `n` long. + fn insert_ref<'a>(list: &mut Vec>, ref_idx: usize, n: usize, target: &'a DpbEntry, is_long: bool) { + for c in (ref_idx + 1..=n).rev() { + list[c] = list[c - 1]; + } + list[ref_idx] = Some(target); + let mut nidx = ref_idx + 1; + for c in ref_idx + 1..=n { + let keep = match list[c] { + None => true, + Some(e) => { + if is_long { + !(e.mark == RefMark::Long && e.long_term_frame_idx == target.long_term_frame_idx) + } else { + !(e.mark == RefMark::Short && std::ptr::eq(e, target)) + } + } + }; + if keep { + list[nidx] = list[c]; + nidx += 1; + } + } + list.truncate(n); + } + /// Reference picture list modification (8.2.4.3) of one list; `n` is num_ref_idx_active. fn modify_ref_list<'a>( list: &mut Vec>, @@ -223,16 +265,8 @@ impl Dpb { list.push(None); // temporarily one longer let (target, is_long): (Option<&DpbEntry>, bool) = match m.idc { 0 | 1 => { - let d = m.value as i32 + 1; - let no_wrap = if m.idc == 0 { - if pred - d < 0 { pred - d + max_pic_num } else { pred - d } - } else if pred + d >= max_pic_num { - pred + d - max_pic_num - } else { - pred + d - }; + let (no_wrap, pn) = Self::short_term_pic_nums(pred, m.idc, m.value, curr_pic_num, max_pic_num); pred = no_wrap; - let pn = if no_wrap > curr_pic_num { no_wrap - max_pic_num } else { no_wrap }; (short.iter().copied().find(|e| Self::frame_num_wrap(e, cur_fn, max_frame_num) == pn), false) } 2 => (long.iter().copied().find(|e| e.long_term_frame_idx == m.value), true), @@ -244,29 +278,8 @@ impl Dpb { ref_idx += 1; continue; }; - for c in (ref_idx + 1..=n).rev() { - list[c] = list[c - 1]; - } - list[ref_idx] = Some(target); + Self::insert_ref(list, ref_idx, n, target, is_long); ref_idx += 1; - let mut nidx = ref_idx; - for c in ref_idx..=n { - let keep = match list[c] { - None => true, - Some(e) => { - if is_long { - !(e.mark == RefMark::Long && e.long_term_frame_idx == target.long_term_frame_idx) - } else { - !(e.mark == RefMark::Short && std::ptr::eq(e, target)) - } - } - }; - if keep { - list[nidx] = list[c]; - nidx += 1; - } - } - list.truncate(n); } Ok(()) } diff --git a/crates/hevc/src/slicedec.rs b/crates/hevc/src/slicedec.rs index 5bf9f07b..6cc24cdc 100644 --- a/crates/hevc/src/slicedec.rs +++ b/crates/hevc/src/slicedec.rs @@ -277,6 +277,30 @@ pub struct SliceDecoder<'a> { pub ctb_y: i32, } +/// Scaling process (8.6.3): dequantises the top-left `max_x` × `max_y` coefficients of the `n` × `n` +/// block `coeffs` with scaling matrix `m` (flat when `None`). +fn dequantize(coeffs: &mut [i32], n: usize, (max_x, max_y): (usize, usize), m: Option<&[u8]>, scale: i64, round: i64, bd_shift: u32) { + for y in 0..=max_y { + for x in 0..=max_x { + let v = coeffs[y * n + x]; + if v != 0 { + let f = m.map_or(16, |m| m[y * n + x] as i64); + coeffs[y * n + x] = ((v as i64 * f * scale + round) >> bd_shift).clamp(-32768, 32767) as i32; + } + } + } +} + +/// Adds the `n` × `n` residual `coeffs` to the samples of `plane` at (x0, y0), clipped to 0..=`max`. +fn add_residual(plane: &mut [u16], stride: usize, (x0, y0): (usize, usize), n: usize, coeffs: &[i32], max: i32) { + for y in 0..n { + let row = &mut plane[(y0 + y) * stride + x0..][..n]; + for (x, s) in row.iter_mut().enumerate() { + *s = (*s as i32 + coeffs[y * n + x]).clamp(0, max) as u16; + } + } +} + impl<'a> SliceDecoder<'a> { #[inline(always)] fn dd(&mut self, ctx: usize) -> u32 { @@ -1331,15 +1355,7 @@ impl<'a> SliceDecoder<'a> { } _ => None, }; - for y in 0..=max_y { - for x in 0..=max_x { - let v = coeffs[y * n + x]; - if v != 0 { - let f = m.map_or(16, |m| m[y * n + x] as i64); - coeffs[y * n + x] = ((v as i64 * f * scale + round) >> bd_shift).clamp(-32768, 32767) as i32; - } - } - } + dequantize(coeffs, n, (max_x, max_y), m, scale, round, bd_shift); let bd_shift = 20 - bd; if ts { transform::transform_skip(coeffs, n, bd_shift); @@ -1355,12 +1371,7 @@ impl<'a> SliceDecoder<'a> { let _ = dc_only; let (stride, max) = (if c == 0 { self.pic.width } else { self.pic.cwidth }, (1i32 << bd) - 1); let plane = &mut self.pic.planes[c]; - for y in 0..n { - let row = &mut plane[(y0 as usize + y) * stride + x0 as usize..][..n]; - for (x, s) in row.iter_mut().enumerate() { - *s = (*s as i32 + coeffs[y * n + x]).clamp(0, max) as u16; - } - } + add_residual(plane, stride, (x0 as usize, y0 as usize), n, coeffs, max); Ok(()) } diff --git a/crates/model/src/chart.rs b/crates/model/src/chart.rs index 9d3dc738..b689d8c2 100644 --- a/crates/model/src/chart.rs +++ b/crates/model/src/chart.rs @@ -809,22 +809,15 @@ impl Chart { /// near them. /// - All-negative values mirror this: the axis ends at zero when `hi` is above 5/6 of `lo`. /// Mixed signs get headroom at both ends. -pub fn axis_scale( - lo: f64, - hi: f64, - fmin: Option, - fmax: Option, - major: Option, - max_intervals: usize, - headroom: bool, -) -> (f64, f64, f64) { - // Values past ±1e100 aren't axis values; clamping keeps the arithmetic finite. - let fin = |v: Option| v.filter(|v| v.is_finite()).map(|v| v.clamp(-1e100, 1e100)); - let (fmin, fmax) = (fin(fmin), fin(fmax)); - let (lo, hi) = if lo.is_finite() && hi.is_finite() { (lo.min(hi).clamp(-1e100, 1e100), lo.max(hi).clamp(-1e100, 1e100)) } else { (0.0, 1.0) }; - // Office's automatic limits ("How chart axis limits are determined", as Jon Peltier - // summarises it): 5 % of the data range past the data, and zero when the values don't - // sit within the top sixth of their largest magnitude. A single value is measured from zero. +/// The data range [lo, hi] an axis covers, clamped to ±1e100; (0, 1) without finite values. +fn axis_data_range(lo: f64, hi: f64) -> (f64, f64) { + if lo.is_finite() && hi.is_finite() { (lo.min(hi).clamp(-1e100, 1e100), lo.max(hi).clamp(-1e100, 1e100)) } else { (0.0, 1.0) } +} + +/// Office's automatic (min, max) of the data range [lo, hi]. "How chart axis limits are determined", +/// as Jon Peltier summarises it: 5 % of the data range past the data, and zero when the values don't +/// sit within the top sixth of their largest magnitude. A single value is measured from zero. +fn auto_limits(lo: f64, hi: f64, headroom: bool) -> (f64, f64) { let flat = hi - lo <= 1e-12 * lo.abs().max(hi.abs()); let pad = if !headroom { 0.0 @@ -835,21 +828,23 @@ pub fn axis_scale( }; let auto_lo = if lo >= 0.0 && (flat || lo < hi * 5.0 / 6.0) { 0.0 } else { lo - pad }; let auto_hi = if hi <= 0.0 && (flat || hi > lo * 5.0 / 6.0) { 0.0 } else { hi + pad }; - let mut lo = fmin.unwrap_or(auto_lo); - let mut hi = fmax.unwrap_or(auto_hi); - let mag = lo.abs().max(hi.abs()); - // Relative to the data's magnitude, so tiny values don't count as flat; all-zero falls back to 1. - let unit = if mag == 0.0 { 1.0 } else { mag }; - if hi - lo <= 1e-12 * mag { - // A fixed limit on the far side of the data: the automatic end gives way. - match (fmin, fmax) { - (None, Some(_)) => lo = if hi > 0.0 { 0.0 } else { hi - hi.abs().max(unit) }, - (Some(_), None) if lo < 0.0 => hi = 0.0, - _ => hi = lo + unit, - } + (auto_lo, auto_hi) +} + +/// The ends of a span too small to show: with one fixed limit on the far side of the data, the +/// automatic end gives way; otherwise the span is one `unit` wide. +fn flat_span_ends(fmin: Option, fmax: Option, lo: f64, hi: f64, unit: f64) -> (f64, f64) { + match (fmin, fmax) { + (None, Some(_)) => (if hi > 0.0 { 0.0 } else { hi - hi.abs().max(unit) }, hi), + (Some(_), None) if lo < 0.0 => (lo, 0.0), + _ => (lo, lo + unit), } - let n = max_intervals.clamp(1, 50) as f64; - let step = match fin(major).filter(|m| *m > 0.0 && (hi - lo) / m <= 1000.0) { +} + +/// The major step: `major` when it gives at most 1000 intervals, else the smallest 1-2-5 step +/// that fits `n` intervals over [lo, hi]. +fn axis_step(major: Option, lo: f64, hi: f64, n: f64, unit: f64) -> f64 { + match major.filter(|m| *m > 0.0 && (hi - lo) / m <= 1000.0) { Some(m) => m, None => { let mut step = 10f64.powf(((hi - lo) / n).log10().floor()); @@ -865,7 +860,32 @@ pub fn axis_scale( } step } - }; + } +} + +pub fn axis_scale( + lo: f64, + hi: f64, + fmin: Option, + fmax: Option, + major: Option, + max_intervals: usize, + headroom: bool, +) -> (f64, f64, f64) { + // Values past ±1e100 aren't axis values; clamping keeps the arithmetic finite. + let fin = |v: Option| v.filter(|v| v.is_finite()).map(|v| v.clamp(-1e100, 1e100)); + let (fmin, fmax) = (fin(fmin), fin(fmax)); + let (lo, hi) = axis_data_range(lo, hi); + let (auto_lo, auto_hi) = auto_limits(lo, hi, headroom); + let (mut lo, mut hi) = (fmin.unwrap_or(auto_lo), fmax.unwrap_or(auto_hi)); + let mag = lo.abs().max(hi.abs()); + // Relative to the data's magnitude, so tiny values don't count as flat; all-zero falls back to 1. + let unit = if mag == 0.0 { 1.0 } else { mag }; + if hi - lo <= 1e-12 * mag { + (lo, hi) = flat_span_ends(fmin, fmax, lo, hi, unit); + } + let n = max_intervals.clamp(1, 50) as f64; + let step = axis_step(fin(major), lo, hi, n, unit); let min = fmin.unwrap_or((lo / step + 1e-9).floor() * step); let max = fmax.unwrap_or((hi / step - 1e-9).ceil() * step).max(min + step); (min, max, step) diff --git a/crates/pptx/src/read/dml.rs b/crates/pptx/src/read/dml.rs index f664a79c..e96fcd22 100644 --- a/crates/pptx/src/read/dml.rs +++ b/crates/pptx/src/read/dml.rs @@ -576,6 +576,44 @@ pub fn text_body(imp: &mut Imp, part: &Part, tx: &El) -> TextBody { const MAX_PARAGRAPH_RUNS: usize = 10_000; +/// The run properties of `e`'s `rPr` child, or the defaults. +fn run_props(imp: &mut Imp, part: &Part, e: &El) -> RunProps { + e.child("rPr").map(|r| rpr(imp, part, r)).unwrap_or_default() +} + +/// Appends the runs of an `a:r` text, where a vertical tab or line feed is a line break, as it +/// lays out and as export writes it. +fn push_text_runs(para: &mut Paragraph, props: RunProps, text: &str) { + for (i, piece) in text.split(['\u{b}', '\n']).enumerate() { + if para.runs.len() >= MAX_PARAGRAPH_RUNS { + break; + } + if i > 0 { + para.runs.push(Run { text: String::new(), props: props.clone(), kind: RunKind::Break }); + } + if !piece.is_empty() { + if para.runs.len() >= MAX_PARAGRAPH_RUNS { + break; + } + para.runs.push(Run { text: piece.to_string(), props: props.clone(), kind: RunKind::Text }); + } + } +} + +/// Appends an Office Math (a14:m) run: its plain text and its OMML. +fn push_math_run(para: &mut Paragraph, part: &Part, e: &El) { + if para.runs.len() < MAX_PARAGRAPH_RUNS { + let mut text = String::new(); + let mut ts = vec![]; + e.find_all("t", &mut ts); + for t in ts { + text.push_str(&t.text()); + } + let omml = e.elements().map(|c| part.keep_inner(c)).collect::(); + para.runs.push(Run { text, props: RunProps::default(), kind: RunKind::Math { omml } }); + } +} + pub fn paragraph(imp: &mut Imp, part: &Part, p: &El) -> Paragraph { let mut para = Paragraph::default(); for e in p.elements() { @@ -589,50 +627,24 @@ pub fn paragraph(imp: &mut Imp, part: &Part, p: &El) -> Paragraph { } } "r" => { - let props = e.child("rPr").map(|r| rpr(imp, part, r)).unwrap_or_default(); + let props = run_props(imp, part, e); let text: String = e.child("t").map(|t| t.text()).unwrap_or_default(); - // A vertical tab or line feed inside text is a line break, as it lays out and as export writes it. - for (i, piece) in text.split(['\u{b}', '\n']).enumerate() { - if para.runs.len() >= MAX_PARAGRAPH_RUNS { - break; - } - if i > 0 { - para.runs.push(Run { text: String::new(), props: props.clone(), kind: RunKind::Break }); - } - if !piece.is_empty() { - if para.runs.len() >= MAX_PARAGRAPH_RUNS { - break; - } - para.runs.push(Run { text: piece.to_string(), props: props.clone(), kind: RunKind::Text }); - } - } + push_text_runs(&mut para, props, &text); } "br" => { if para.runs.len() < MAX_PARAGRAPH_RUNS { - let props = e.child("rPr").map(|r| rpr(imp, part, r)).unwrap_or_default(); + let props = run_props(imp, part, e); para.runs.push(Run { text: String::new(), props, kind: RunKind::Break }); } } "fld" => { if para.runs.len() < MAX_PARAGRAPH_RUNS { - let props = e.child("rPr").map(|r| rpr(imp, part, r)).unwrap_or_default(); + let props = run_props(imp, part, e); let text = e.child("t").map(|t| t.text()).unwrap_or_default(); para.runs.push(Run { text, props, kind: RunKind::Field { field: e.attr("type").unwrap_or("").to_string() } }); } } - "m" => { - if para.runs.len() < MAX_PARAGRAPH_RUNS { - // Office Math (a14:m) — keep the OMML and its plain text. - let mut text = String::new(); - let mut ts = vec![]; - e.find_all("t", &mut ts); - for t in ts { - text.push_str(&t.text()); - } - let omml = e.elements().map(|c| part.keep_inner(c)).collect::(); - para.runs.push(Run { text, props: RunProps::default(), kind: RunKind::Math { omml } }); - } - } + "m" => push_math_run(&mut para, part, e), "endParaRPr" => para.end_props = rpr(imp, part, e), _ => {} }