fix: preserve RAW identity and SVG byte-limit reporting

This commit is contained in:
Terra854 committed 2026-11-15 03:49:35 +08:00
1 parent eec8408c53
commit 58ef208c13
10 files changed
+529 -29

No files matched your search

+98 -15
View File
@@ -361,28 +361,47 @@ fn trak(bytes: &[u8], t: &BoxRef, budget: &mut usize) -> Option<Cr3Track> {
// Only the first sample is exposed. It must map chunk 1 to
// the first sample description; don't trust offsets without
// that mapping, or a damaged/raw track could become a JPEG.
mapping = None;
let count = be32(body, 4)? as usize;
if be32(body, 0)? == 0 && count > 0 && count <= body.len().saturating_sub(8) / 12 {
mapping = Some((be32(body, 8)?, be32(body, 12)?, be32(body, 16)?));
}
// A malformed mapping invalidates sample data, not the track's
// identity: dropping the largest raw track could select a reduced
// raw successfully and disguise corruption in the main image.
mapping = (|| {
let count = be32(body, 4)? as usize;
if be32(body, 0)? != 0 || count == 0 || count > body.len().saturating_sub(8) / 12 {
return None;
}
Some((be32(body, 8)?, be32(body, 12)?, be32(body, 16)?))
})();
}
// version/flags, sample_size (0 = per-sample table), count, sizes
b"stsz" => {
sample_count = be32(body, 8)?;
size = match be32(body, 4)? {
// A truncated size table invalidates data without hiding a known track.
sample_count = be32(body, 8).unwrap_or(0);
size = match be32(body, 4) {
// A first entry cannot justify an incomplete per-sample
// table, nor an impossible constant-size sample count.
0 if sample_count > 0 && sample_count as usize <= body.len().saturating_sub(12) / 4 => be32(body, 12),
0 => None,
n if sample_count > 0 && u64::from(n).checked_mul(u64::from(sample_count)).is_some_and(|total| total <= bytes.len() as u64) => {
Some(0) if sample_count > 0 && sample_count as usize <= body.len().saturating_sub(12) / 4 => be32(body, 12),
Some(n)
if n > 0
&& sample_count > 0
&& u64::from(n).checked_mul(u64::from(sample_count)).is_some_and(|total| total <= bytes.len() as u64) =>
{
Some(n)
}
_ => None,
}
}
b"co64" if be32(body, 4)? > 0 => offset = be64(body, 8).and_then(|v| usize::try_from(v).ok()),
b"stco" if be32(body, 4)? > 0 => offset = be32(body, 8).map(|v| v as usize),
// Missing offset-table counts deny sample access, but the known
// track must remain available to the largest-raw-track selector.
b"co64" => match be32(body, 4) {
Some(count) if count > 0 => offset = be64(body, 8).and_then(|v| usize::try_from(v).ok()),
None => offset = None,
_ => {}
},
b"stco" => match be32(body, 4) {
Some(count) if count > 0 => offset = be32(body, 8).map(|v| v as usize),
None => offset = None,
_ => {}
},
_ => {}
}
}
@@ -514,6 +533,13 @@ mod tests {
bx(b"CRAW", &b)
}
fn trak(entry: Vec<u8>, offset: u64, size: u32) -> Vec<u8> {
let stsc = [1u32, 1, 1, 1].into_iter().flat_map(u32::to_be_bytes).collect::<Vec<_>>();
trak_with_mapping(entry, offset, size, &stsc)
}
fn trak_with_mapping(entry: Vec<u8>, offset: u64, size: u32, mapping: &[u8]) -> Vec<u8> {
trak_with_table(entry, offset, size, b"stsc", mapping)
}
fn trak_with_table(entry: Vec<u8>, offset: u64, size: u32, table: &[u8; 4], payload: &[u8]) -> Vec<u8> {
let mut stsd = 1u32.to_be_bytes().to_vec();
stsd.extend(entry);
let mut stsz = 0u32.to_be_bytes().to_vec();
@@ -522,7 +548,14 @@ mod tests {
let mut co64 = 1u32.to_be_bytes().to_vec();
co64.extend(offset.to_be_bytes());
let stsc = [1u32, 1, 1, 1].into_iter().flat_map(u32::to_be_bytes).collect::<Vec<_>>();
let stbl = [full(b"stsd", &stsd), full(b"stsc", &stsc), full(b"stsz", &stsz), full(b"co64", &co64)].concat();
let offsets = if table == b"stco" { full(b"stco", payload) } else { full(b"co64", if table == b"co64" { payload } else { &co64 }) };
let stbl = [
full(b"stsd", &stsd),
full(b"stsc", if table == b"stsc" { payload } else { &stsc }),
full(b"stsz", if table == b"stsz" { payload } else { &stsz }),
offsets,
]
.concat();
bx(b"trak", &bx(b"mdia", &bx(b"minf", &bx(b"stbl", &stbl))))
}
fn tiff_with(tag: u16, v: craft_tiff::Value) -> Vec<u8> {
@@ -582,7 +615,9 @@ mod tests {
damaged[offset..offset + 4].copy_from_slice(&value.to_be_bytes());
let bytes = file(damaged);
let parsed = parse_cr3(&bytes).unwrap();
assert!(parsed.tracks.is_empty() || parsed.tracks[0].data.is_none());
assert_eq!(parsed.tracks.len(), 1, "invalid mapping must not erase an identifiable track");
assert_eq!(parsed.tracks[0].kind, Cr3TrackKind::Jpeg);
assert!(parsed.tracks[0].data.is_none());
}
for entry in [craw(16, 16, &[]), craw(16, 16, &bx(b"CMP1", &[0xff, 0x10, 0, 0x30]))] {
let bytes = file(trak(entry, 4096, 16));
@@ -591,6 +626,51 @@ mod tests {
}
}
#[test]
fn truncated_sample_mapping_preserves_larger_raw_track_identity_and_valid_reduced_track() {
let reduced = trak(craw(4, 4, &bx(b"CMP1", &compression_payload(0))), 4096, 16);
for table in [b"stsc", b"stsz", b"co64", b"stco"] {
for payload in [Vec::new(), vec![0; 4], 1u32.to_be_bytes().to_vec()] {
// full() supplies version/flags; an empty payload leaves only
// those four bytes, with the table's required count missing.
let main = trak_with_table(craw(8, 4, &bx(b"CMP1", &compression_payload(0))), 4112, 32, table, &payload);
for main_first in [false, true] {
let tracks = if main_first { [main.clone(), reduced.clone()].concat() } else { [reduced.clone(), main.clone()].concat() };
let mut file = bx(b"ftyp", b"crx \0\0\0\x01crx isom");
file.extend(bx(b"moov", &tracks));
file.resize(4144, 0);
let parsed = parse_cr3(&file).unwrap();
assert_eq!(parsed.tracks.len(), 2, "truncated {table:?} cannot hide the larger track");
let (main, reduced) = if main_first { (&parsed.tracks[0], &parsed.tracks[1]) } else { (&parsed.tracks[1], &parsed.tracks[0]) };
assert!(matches!(reduced.kind, Cr3TrackKind::Raw { width: 4, height: 4, .. }));
assert_eq!(reduced.data, Some((4096, 16)));
assert!(matches!(main.kind, Cr3TrackKind::Raw { width: 8, height: 4, cmp1: Some(_), .. }));
assert!(main.data.is_none());
assert!(main.compression(&file).is_some(), "only sample location is invalid");
}
}
let mut offsets = 1u32.to_be_bytes().to_vec();
offsets.extend(4112u64.to_be_bytes());
let valid = match table {
b"stsc" => [1u32, 1, 1, 1].into_iter().flat_map(u32::to_be_bytes).collect::<Vec<_>>(),
b"stsz" => [0u32, 1, 32].into_iter().flat_map(u32::to_be_bytes).collect(),
b"stco" => [1u32, 4112].into_iter().flat_map(u32::to_be_bytes).collect(),
_ => offsets,
};
let main = trak_with_table(craw(8, 4, &bx(b"CMP1", &compression_payload(0))), 4112, 32, table, &valid);
for main_first in [false, true] {
let tracks = if main_first { [main.clone(), reduced.clone()].concat() } else { [reduced.clone(), main.clone()].concat() };
let mut file = bx(b"ftyp", b"crx \0\0\0\x01crx isom");
file.extend(bx(b"moov", &tracks));
file.resize(4144, 0);
let parsed = parse_cr3(&file).unwrap();
assert_eq!(parsed.tracks.len(), 2);
let main = &parsed.tracks[if main_first { 0 } else { 1 }];
assert_eq!(main.data, Some((4112, 32)), "complete valid {table:?} stays usable");
}
}
}
#[test]
fn first_sample_size_requires_a_complete_bounded_sample_table() {
let valid = trak(craw(16, 16, &bx(b"JPEG", &[0; 4])), 4096, 16);
@@ -778,7 +858,10 @@ mod tests {
let mut file = bx(b"ftyp", b"crx \0\0\0\x01crx isom");
file.extend(bx(b"moov", &bx(b"trak", &bx(b"mdia", &bx(b"minf", &bx(b"stbl", &stbl))))));
file.resize(512, 0);
assert!(parse_cr3(&file).unwrap().tracks.is_empty());
let parsed = parse_cr3(&file).unwrap();
assert_eq!(parsed.tracks.len(), 1, "a truncated table must not hide the identifiable raw track");
assert!(matches!(parsed.tracks[0].kind, Cr3TrackKind::Raw { width: 16, height: 16, .. }));
assert!(parsed.tracks[0].data.is_none(), "the empty stsz must not borrow size bytes from the following co64 box");
}
#[test]
+36 -4
View File
@@ -734,11 +734,11 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result<RawIma
// agree too. Genuinely packed 12-bit strips retain their 12-bit scale.
let scale_bits = if info.compression == 1 && out_bits < 14 && strip_len >= (w * h * 2) as u64 { 14 } else { out_bits };
let cfa = match (raw.u64s(t::CFA_REPEAT_PATTERN_DIM).as_deref(), raw.bytes(t::CFA_PATTERN_EP)) {
let (cfa, assumed_cfa) = match (raw.u64s(t::CFA_REPEAT_PATTERN_DIM).as_deref(), raw.bytes(t::CFA_PATTERN_EP)) {
(Some([2, 2]), Some(p)) if p.len() == 4 && p.iter().all(|&c| c <= 2) => {
Cfa { width: 2, height: 2, pattern: p.to_vec(), origin_x: 0, origin_y: 0 }
(Cfa { width: 2, height: 2, pattern: p.to_vec(), origin_x: 0, origin_y: 0 }, false)
}
_ => Cfa::bayer_static("RGGB"),
_ => (Cfa::bayer_static("RGGB"), true),
};
let curve_black = (info.compression == 32767 && one_byte_per_sample)
.then(|| declared_curve.as_ref().and_then(|curve| code_curve(curve).get(256).copied()).map(f32::from))
@@ -859,7 +859,7 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result<RawIma
cinema: Default::default(),
lens_metadata: LensMetadata { sony: sony_lens },
level_sources: crate::LevelSources { black: black_source, white: white_source },
notices: crate::RawNotices::default(),
notices: crate::RawNotices { assumed_cfa: assumed_cfa && !linear_rgb, ..Default::default() },
};
img.validate_for(mode)?;
Ok(img)
@@ -891,6 +891,8 @@ mod tests {
assert_eq!(header.info(), full.info());
assert_eq!((full.width, full.height, full.cpp), (4, 4, 3));
assert!(full.cfa.is_none());
assert!(!header.notices.assumed_cfa);
assert!(!full.notices.assumed_cfa);
assert_eq!(full.data.len(), 48);
assert_eq!(full.wb_multipliers, Some([1.0; 3]));
// the YCbCr data sit 512 above the recorded sensor black level; white moves with it
@@ -929,6 +931,10 @@ mod tests {
/// A 32767-compressed ARW whose single strip is `strip` bytes for a 32 x 4 image.
fn arw_with_strip(strip: usize) -> Vec<u8> {
arw_with_strip_and_cfa(strip, None)
}
fn arw_with_strip_and_cfa(strip: usize, cfa: Option<(Vec<u16>, Vec<u8>)>) -> Vec<u8> {
use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value};
let mut raw = IfdBuilder::new();
raw.set(t::MAKE, Value::Ascii("SONY".into()));
@@ -939,11 +945,37 @@ mod tests {
raw.set(t::SAMPLES_PER_PIXEL, Value::Short(vec![1]));
raw.set(t::PHOTOMETRIC, Value::Short(vec![photometric::CFA]));
raw.set(t::COMPRESSION, Value::Short(vec![32767]));
if let Some((dimensions, pattern)) = cfa {
raw.set(t::CFA_REPEAT_PATTERN_DIM, Value::Short(dimensions));
raw.set(t::CFA_PATTERN_EP, Value::Byte(pattern));
}
raw.set(TONE_CURVE, Value::Short(vec![8000, 10400, 12900, 14100]));
raw.set_image(ImageData::Strips { rows_per_strip: 4, strips: vec![vec![0u8; strip]] });
TiffWriter::default().write(&[raw]).unwrap()
}
#[test]
fn cfa_fallback_notices_follow_missing_malformed_and_valid_source_tags() {
for (tags, expected, assumed) in [
(None, "RGGB", true),
(Some((vec![1, 4], vec![0, 1, 1, 2])), "RGGB", true),
(Some((vec![2, 2], vec![0, 1, 3, 2])), "RGGB", true),
(Some((vec![2, 2], vec![0, 1, 2])), "RGGB", true),
(Some((vec![2, 2], vec![1, 0, 2, 1])), "GRBG", false),
] {
let file = arw_with_strip_and_cfa(32 * 4, tags);
let header = decode(&file, Mode::Header, &Limits::default()).unwrap();
let full = decode(&file, Mode::Full, &Limits::default()).unwrap();
assert_eq!(header.info(), full.info());
for image in [&header, &full] {
assert_eq!(image.cfa.as_ref().unwrap().name(), expected);
assert_eq!(image.notices.assumed_cfa, assumed);
}
assert!(header.data.is_empty());
assert_eq!(full.data.len(), 32 * 4);
}
}
/// Strip byte counts that add up past `u64::MAX` (LONG8 `[u64::MAX, 1]`) are an error or a picture, not an overflow.
#[test]
fn strip_byte_counts_past_u64_max_do_not_overflow() {
+30 -1
View File
@@ -113,7 +113,7 @@ fn fallback_cfa(data: &[u16], width: usize, area: Rect, black: f32, white: f32,
let green_first = [0x8000_0218, 0x8000_0250, 0x8000_0270, 0x8000_0286, 0x8000_0327].into_iter().any(|id| model == Some(id));
let measured = measured_red_row(data, width, area, black, white);
let row = measured.unwrap_or(usize::from(green_first));
(Cfa::bayer_static(if row == 1 { "GBRG" } else { "RGGB" }), measured.is_none() && !green_first)
(Cfa::bayer_static(if row == 1 { "GBRG" } else { "RGGB" }), measured.is_none())
}
/// The 16-bit words of a maker-note array. Canon writes `ColorData` as SHORT in most models, but as UNDEFINED
@@ -511,12 +511,41 @@ pub(crate) mod tests {
let data = vec![512; 64 * 32];
let area = Rect::new(0, 0, 64, 32);
assert_eq!(fallback_cfa(&data, 64, area, 512.0, 16000.0, Some(0x8000_0250)).0.name(), "GBRG");
assert!(fallback_cfa(&data, 64, area, 512.0, 16000.0, Some(0x8000_0250)).1);
assert_eq!(fallback_cfa(&data, 64, area, 512.0, 16000.0, None).0.name(), "RGGB");
assert!(fallback_cfa(&data, 64, area, 512.0, 16000.0, None).1);
for (width, area) in [(0, area), (64, Rect::new(usize::MAX, usize::MAX, 3, 3)), (64, Rect::new(63, 31, 1, 1))] {
assert_eq!(measured_red_row(&data, width, area, 512.0, 16000.0), None);
}
}
#[test]
fn model_cfa_fallback_is_disclosed_in_header_and_full_decodes() {
// A single inline LONG maker-note entry needs no external offsets.
let mut note = Vec::new();
note.extend_from_slice(&1u16.to_le_bytes());
note.extend_from_slice(&CANON_MODEL_ID.to_le_bytes());
note.extend_from_slice(&4u16.to_le_bytes());
note.extend_from_slice(&1u32.to_le_bytes());
note.extend_from_slice(&0x8000_0250u32.to_le_bytes());
note.extend_from_slice(&0u32.to_le_bytes());
let samples = vec![512u16; 64 * 32];
let mut bytes = synthetic_cr2_of(&samples, 64, 32, None, Some(note));
let marker = [0xe0, 0xc5, 4, 0, 1, 0, 0, 0];
let at = bytes.windows(marker.len()).position(|b| b == marker).unwrap();
// Remove only the CFA tag; the model ID and encoded samples stay intact.
bytes[at..at + 2].copy_from_slice(&0xc5dfu16.to_le_bytes());
let header = decode(&bytes, Mode::Header, &Limits::default()).unwrap();
let full = decode(&bytes, Mode::Full, &Limits::default()).unwrap();
for image in [&header, &full] {
assert_eq!(image.cfa.as_ref().unwrap().name(), "GBRG");
assert!(image.notices.assumed_cfa);
}
assert_eq!(header.info(), full.info());
assert_eq!(full.data, RawData::U16(samples));
assert!(header.data.is_empty());
}
#[test]
fn wb_probe() {
let mut v = vec![0u64; 120];
+117 -2
View File
@@ -405,6 +405,15 @@ mod tests {
}
fn track(entry: &[u8], offset: u64, size: u32) -> Vec<u8> {
let mapping = [0u32, 1, 1, 1, 1].into_iter().flat_map(u32::to_be_bytes).collect::<Vec<_>>();
track_with_mapping(entry, offset, size, &mapping)
}
fn track_with_mapping(entry: &[u8], offset: u64, size: u32, mapping: &[u8]) -> Vec<u8> {
track_with_table(entry, offset, size, b"stsc", mapping)
}
fn track_with_table(entry: &[u8], offset: u64, size: u32, table: &[u8; 4], payload: &[u8]) -> Vec<u8> {
let mut stsd = vec![0u8; 4];
stsd.extend(1u32.to_be_bytes());
stsd.extend(entry);
@@ -414,8 +423,15 @@ mod tests {
let mut co64 = vec![0u8; 4];
co64.extend(1u32.to_be_bytes());
co64.extend(offset.to_be_bytes());
let stsc = [0u32, 1, 1, 1, 1].into_iter().flat_map(u32::to_be_bytes).collect::<Vec<_>>();
let tables = [box_bytes(b"stsd", &stsd), box_bytes(b"stsc", &stsc), box_bytes(b"stsz", &stsz), box_bytes(b"co64", &co64)].concat();
let mapping = [0u32, 1, 1, 1, 1].into_iter().flat_map(u32::to_be_bytes).collect::<Vec<_>>();
let offsets = if table == b"stco" { box_bytes(b"stco", payload) } else { box_bytes(b"co64", if table == b"co64" { payload } else { &co64 }) };
let tables = [
box_bytes(b"stsd", &stsd),
box_bytes(b"stsc", if table == b"stsc" { payload } else { &mapping }),
box_bytes(b"stsz", if table == b"stsz" { payload } else { &stsz }),
offsets,
]
.concat();
box_bytes(b"trak", &box_bytes(b"mdia", &box_bytes(b"minf", &box_bytes(b"stbl", &tables))))
}
@@ -638,6 +654,105 @@ mod tests {
assert!(matches!(decode(&missing, Mode::Header, &Limits::default()), Err(RawError::Corrupt(_))));
}
/// Independently framed constant-value CRX: each 4x4 tile has four 2x2
/// planes whose one-byte 0x1e entropy streams reconstruct sensor value8193.
fn flat_raw_track(tiles: u32) -> (Vec<u8>, Vec<u8>) {
let mut sample = Vec::new();
let marker = |out: &mut Vec<u8>, code: u16, size: u32, flags: u32| {
out.extend(code.to_be_bytes());
out.extend(8u16.to_be_bytes());
out.extend(size.to_be_bytes());
out.extend(flags.to_be_bytes());
};
for tile in 0..tiles {
marker(&mut sample, 0xff01, 4, tile << 16);
for plane in 0..4 {
marker(&mut sample, 0xff02, 1, (plane << 28) | 0x0800_0000);
marker(&mut sample, 0xff03, 1, 0x0020_0000);
}
}
let header_size = sample.len() as u32;
sample.extend(std::iter::repeat_n(0x1e, tiles as usize * 4));
let mut coding = vec![0u8; 52];
coding[..2].copy_from_slice(&0xff00u16.to_be_bytes());
coding[2..4].copy_from_slice(&48u16.to_be_bytes());
coding[4..6].copy_from_slice(&0x100u16.to_be_bytes());
for (offset, value) in [(8, tiles * 4), (12, 4), (16, 4), (20, 4), (28, header_size)] {
coding[offset..offset + 4].copy_from_slice(&value.to_be_bytes());
}
coding[24] = 14;
coding[25] = 0x40;
let mut entry = vec![0u8; 82];
entry[24..26].copy_from_slice(&((tiles * 4) as u16).to_be_bytes());
entry[26..28].copy_from_slice(&4u16.to_be_bytes());
entry.extend(box_bytes(b"CMP1", &coding));
(box_bytes(b"CRAW", &entry), sample)
}
#[test]
fn truncated_main_sample_mapping_cannot_silently_select_a_valid_reduced_raw() {
let mapping = [0u32, 1, 1, 1, 1].into_iter().flat_map(u32::to_be_bytes).collect::<Vec<_>>();
let (reduced_entry, reduced_sample) = flat_raw_track(1);
let (main_entry, main_sample) = flat_raw_track(2);
let main_offset = 4096 + reduced_sample.len();
let file = |main_table: Option<(&[u8; 4], &[u8])>, main_first: bool| {
let reduced = track_with_mapping(&reduced_entry, 4096, reduced_sample.len() as u32, &mapping);
let tracks = if let Some((table, payload)) = main_table {
let main = track_with_table(&main_entry, main_offset as u64, main_sample.len() as u32, table, payload);
if main_first { [main, reduced].concat() } else { [reduced, main].concat() }
} else {
reduced
};
let mut bytes = box_bytes(b"ftyp", b"crx \0\0\0\x01crx isom");
bytes.extend(box_bytes(b"moov", &tracks));
assert!(bytes.len() < 4096);
bytes.resize(4096, 0);
bytes.extend_from_slice(&reduced_sample);
bytes.extend_from_slice(&main_sample);
bytes
};
let mut co64 = vec![0u8; 4];
co64.extend(1u32.to_be_bytes());
co64.extend((main_offset as u64).to_be_bytes());
let valid_tables = [
(b"stsc", mapping.clone()),
(b"stsz", [0u32, main_sample.len() as u32, 1].into_iter().flat_map(u32::to_be_bytes).collect()),
(b"co64", co64),
(b"stco", [0u32, 1, main_offset as u32].into_iter().flat_map(u32::to_be_bytes).collect()),
];
for mode in [Mode::Header, Mode::Full] {
// The smaller source is genuinely decodable, so dropping the larger
// track would return success rather than merely a different failure.
let reduced = decode(&file(None, false), mode, &Limits::default()).unwrap();
assert_eq!((reduced.width, reduced.height), (4, 4));
if mode == Mode::Full {
assert_eq!(reduced.data, RawData::U16(vec![8193; 16]));
}
for main_first in [false, true] {
for (table, payload) in &valid_tables {
let valid = decode(&file(Some((table, payload)), main_first), mode, &Limits::default()).unwrap();
assert_eq!((valid.width, valid.height), (8, 4));
if mode == Mode::Full {
assert_eq!(valid.data, RawData::U16(vec![8193; 32]));
}
for truncated in [vec![], vec![0; 4], vec![0, 0, 0, 0, 0, 0, 0, 1]] {
let bytes = file(Some((table, &truncated)), main_first);
let container = parse_cr3(&bytes).unwrap();
assert_eq!(container.tracks.len(), 2, "mapping damage cannot erase the main track");
let selected = main_track(&container.tracks).unwrap();
assert!(matches!(selected.kind, Cr3TrackKind::Raw { width: 8, height: 4, .. }));
assert!(selected.data.is_none());
assert!(selected.compression(&bytes).is_some());
assert!(
matches!(decode(&bytes, mode, &Limits::default()), Err(RawError::Corrupt(message)) if message.contains("sample")),
"{mode:?}/{table:?}: main mapping damage cannot decode the reduced source"
);
}
}
}
}
}
#[test]
fn color_data_uses_versioned_as_shot_offsets() {
for (version, wb_at, black_at, white_at) in
+24 -1
View File
@@ -315,6 +315,7 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result<RawIma
}
_ => Rect::new(0, 0, w, h),
};
let assumed_cfa = stated.is_none();
let cfa = stated.unwrap_or_else(|| cfa_from_data(samples, w, active));
let (black, black_source) = match ip.as_ref().and_then(|i| i.f64s(BLACK)).as_deref() {
Some(v @ [_, _, _, _]) => {
@@ -361,7 +362,7 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result<RawIma
camera: tiff.ifds.first().map(Camera::from_ifd0).unwrap_or_default(),
cinema: Default::default(),
lens_metadata: Default::default(),
notices: Default::default(),
notices: crate::RawNotices { assumed_cfa, ..Default::default() },
level_sources: crate::LevelSources { black: black_source, white: white_source },
};
img.validate_for(mode)?;
@@ -669,6 +670,28 @@ mod tests {
}
}
#[test]
fn cfa_notice_distinguishes_missing_and_unusable_exif_from_stated_patterns() {
let (w, h) = (160usize, 144usize);
let strip = mosaic(w, h, |cx, cy| [600, 1000, 1000, 300].map(|value| value + shade(cx, cy)));
let expected: Vec<u16> = strip.as_chunks::<2>().0.iter().map(|word| u16::from_le_bytes(*word)).collect();
for (tag, assumed, pattern) in [
(None, true, "RGGB"),
(Some(&[2, 0, 2, 0, 0, 1][..]), true, "RGGB"),
(Some(&[2, 0, 2, 0, 0, 1, 1, 3][..]), true, "RGGB"),
(Some(BGGR), false, "BGGR"),
(Some(GRBG), false, "GRBG"),
] {
let bytes = orf_with(w as u32, h as u32, 16, strip.clone(), tag);
for mode in [Mode::Header, Mode::Full] {
let image = decode(&bytes, mode, &Limits::default()).unwrap();
assert_eq!(image.cfa, Some(Cfa::bayer_static(pattern)));
assert_eq!(image.data, RawData::U16(expected.clone()), "word16 samples remain unchanged");
assert_eq!(image.notices, crate::RawNotices { assumed_cfa: assumed, ..Default::default() });
}
}
}
#[test]
fn packed_12_bit_probe_agrees_with_decode() {
let (w, h) = (16usize, 4usize);
+47 -2
View File
@@ -194,6 +194,7 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result<RawIma
Some(r) => r,
None => dark_trimmed(samples, w, hgt, black_point.as_deref().map(|v| v.iter().sum::<f64>() / 4.0), white),
};
let mut assumed_cfa = false;
let cfa = match (ifd0.u64s(t::CFA_REPEAT_PATTERN_DIM).as_deref(), ifd0.bytes(t::CFA_PATTERN_EP)) {
(Some([2, 2]), Some(p)) if p.len() == 4 && p.iter().all(|&c| c <= 2) => {
Cfa { width: 2, height: 2, pattern: p.to_vec(), origin_x: 0, origin_y: 0 }
@@ -202,7 +203,10 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result<RawIma
// of the image area: the *ist D (origin 19, 11) and the 645D (80, 59) only fit unshifted. The 12-bit 10 MP
// bodies and everything from the K-3 on say RGGB; the K-7 / K-5 / 645D generation says BGGR. Files without the
// tag keep BGGR.
_ => cfa_from_exif(&tiff).unwrap_or_else(|| Cfa::bayer_static("BGGR")),
_ => cfa_from_exif(&tiff).unwrap_or_else(|| {
assumed_cfa = true;
Cfa::bayer_static("BGGR")
}),
};
let black = match black_point.as_deref() {
Some(v @ [_, _, _, _]) => {
@@ -240,7 +244,7 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result<RawIma
cinema: Default::default(),
lens_metadata: Default::default(),
level_sources: Default::default(),
notices: crate::RawNotices::default(),
notices: crate::RawNotices { assumed_cfa, ..Default::default() },
};
img.validate_for(mode)?;
Ok(img)
@@ -488,6 +492,47 @@ mod tests {
assert_eq!(img.cfa, Some(Cfa::bayer_static("BGGR")));
}
#[test]
fn fixed_cfa_fallback_is_noticed_but_either_usable_metadata_form_is_not_assumed() {
use craft_tiff::{IfdBuilder, ImageData, TiffWriter, Value};
let expected: Vec<u16> = (0..16).map(|i| 100 + i * 7).collect();
let valid_exif = &[2, 0, 2, 0, 1, 0, 2, 1][..];
let invalid_exif = &[2, 0, 2, 0, 1, 0][..];
for (primary, exif, assumed, pattern) in [
(None, None, true, "BGGR"),
(Some([0, 1, 1, 3]), None, true, "BGGR"),
(None, Some(invalid_exif), true, "BGGR"),
(Some([0, 1, 1, 3]), Some(invalid_exif), true, "BGGR"),
(Some([0, 1, 1, 3]), Some(valid_exif), false, "GRBG"),
(None, Some(valid_exif), false, "GRBG"),
(Some([0, 1, 1, 2]), None, false, "RGGB"),
(Some([0, 1, 1, 2]), Some(valid_exif), false, "RGGB"),
] {
let mut raw = IfdBuilder::new();
raw.set(t::IMAGE_WIDTH, Value::Long(vec![4]));
raw.set(t::IMAGE_LENGTH, Value::Long(vec![4]));
raw.set(t::BITS_PER_SAMPLE, Value::Short(vec![16]));
raw.set(t::COMPRESSION, Value::Short(vec![1]));
raw.set(t::PHOTOMETRIC, Value::Short(vec![32803]));
raw.set(t::MAKE, Value::Ascii("PENTAX Corporation".into()));
if let Some(pattern) = primary {
raw.set(t::CFA_REPEAT_PATTERN_DIM, Value::Short(vec![2, 2]));
raw.set(t::CFA_PATTERN_EP, Value::Byte(pattern.to_vec()));
}
if let Some(pattern) = exif {
raw.set_child(t::EXIF_IFD, IfdBuilder::new().with(crate::EXIF_CFA_PATTERN, Value::Undefined(pattern.to_vec())));
}
raw.set_image(ImageData::Strips { rows_per_strip: 4, strips: vec![expected.iter().flat_map(|value| value.to_be_bytes()).collect()] });
let bytes = TiffWriter::new(ByteOrder::Big, false).write(&[raw]).unwrap();
for mode in [Mode::Header, Mode::Full] {
let image = decode(&bytes, mode, &Limits::default()).unwrap();
assert_eq!(image.cfa, Some(Cfa::bayer_static(pattern)));
assert_eq!(image.data, RawData::U16(expected.clone()));
assert_eq!(image.notices, crate::RawNotices { assumed_cfa: assumed, ..Default::default() });
}
}
}
/// A `w x h` big-endian 14-bit PEF of plain 16-bit words without area tags, whose maker note has only a
/// BlackPoint of `black`, with `px(x, y)` as the samples.
fn pef_with_black_point(w: usize, h: usize, black: u16, px: impl Fn(usize, usize) -> u16) -> Vec<u8> {
+40 -2
View File
@@ -136,7 +136,9 @@ fn cfa(h: &Header) -> Result<Cfa> {
}
let Some(l) = record(h, 0x0130) else { return Ok(Cfa::bayer_static("RGGB")) };
let cfa = Cfa { width: 2, height: 2, pattern: l.iter().rev().map(|&c| if c & 3 == 3 { 1 } else { c & 3 }).collect(), origin_x: 0, origin_y: 0 };
if l.len() != 4 || !cfa.is_bayer() {
// Colour counts alone also accept adjacent green sites; the two greens
// must occupy opposite corners of the 2x2 Bayer repeat.
if l.len() != 4 || !matches!(cfa.pattern.as_slice(), [0, 1, 1, 2] | [2, 1, 1, 0] | [1, 0, 2, 1] | [1, 2, 0, 1]) {
return Err(RawError::Unsupported("Fujifilm RAF with an unknown Bayer layout".into()));
}
Ok(cfa)
@@ -612,12 +614,48 @@ pub(super) mod tests {
#[test]
fn invalid_declared_cfa_layouts_are_not_silently_replaced() {
for (tag, data) in [(0x0130, vec![8, 8, 10, 10]), (0x0131, vec![3; 36])] {
for (tag, data) in [(0x0130, vec![8, 8, 10, 10]), (0x0130, vec![1, 2, 1, 0]), (0x0131, vec![3; 36])] {
let header = Header { jpeg: None, records: vec![(tag, data.as_slice())], raw: None };
assert!(matches!(cfa(&header), Err(RawError::Unsupported(_))));
}
}
fn with_bayer_record(mut bytes: Vec<u8>, pattern: [u8; 4]) -> Vec<u8> {
let (dir_at, raw_at) = (be32(&bytes, 92).unwrap(), be32(&bytes, 100).unwrap());
let mut records = bytes[dir_at..raw_at].to_vec();
let count = u32::from_be_bytes(records[..4].try_into().unwrap()) + 1;
records[..4].copy_from_slice(&count.to_be_bytes());
records.extend_from_slice(&[0x01, 0x30, 0, 4]);
records.extend_from_slice(&pattern);
bytes.splice(dir_at..raw_at, records.clone());
bytes[96..100].copy_from_slice(&(records.len() as u32).to_be_bytes());
bytes[100..104].copy_from_slice(&((raw_at + 8) as u32).to_be_bytes());
bytes
}
#[test]
fn non_bayer_geometry_is_rejected_in_header_and_full_modes() {
// Reversal gives RGBG: correct colour counts, but both greens in one column.
let bytes = with_bayer_record(raf(6, 4, 16, pack(&[1000; 24], 16), None, &[]), [1, 2, 1, 0]);
for mode in [Mode::Header, Mode::Full] {
assert!(matches!(decode(&bytes, mode, &Limits::default()), Err(RawError::Unsupported(why)) if why.contains("Bayer layout")));
}
}
#[test]
fn all_four_bayer_geometries_preserve_the_stored_samples() {
let pixels: Vec<u16> = (0..24).map(|i| 123 + i * 977).collect();
for (stored, expected) in [([2, 1, 1, 0], "RGGB"), ([0, 1, 1, 2], "BGGR"), ([1, 2, 0, 1], "GRBG"), ([1, 0, 2, 1], "GBRG")] {
let bytes = with_bayer_record(raf(6, 4, 16, pack(&pixels, 16), None, &[]), stored);
for mode in [Mode::Header, Mode::Full] {
let image = decode(&bytes, mode, &Limits::default()).unwrap();
assert_eq!((image.width, image.height), (6, 4));
assert_eq!(image.cfa.as_ref().unwrap().name(), expected);
assert_eq!(image.data, RawData::U16(if mode == Mode::Full { pixels.clone() } else { Vec::new() }));
}
}
}
#[test]
fn compressed_bayer_requires_the_layout_assumed_by_its_predictor() {
let strip = b"IS\x01\x00\x0e\0\x12\x06\0\x03\x0c\x03\0\x02\0\x03".to_vec();
+35 -2
View File
@@ -622,7 +622,11 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result<RawIma
fill_defects(&mut data, w, active);
}
let cfa = cfa(ifd0.u16(CFA_PATTERN).unwrap_or(1));
let cfa_code = ifd0.u16(CFA_PATTERN);
// RGGB is still usable when metadata is absent or unknown, but callers
// must be able to distinguish that fallback from a recorded sensor phase.
let assumed_cfa = !matches!(cfa_code, Some(1..=4));
let cfa = cfa(cfa_code.unwrap_or(1));
let read = BLACK_RGB.map(|tag| ifd0.f64(tag).filter(|v| v.is_finite() && *v >= 0.0));
let tags = read.map(|v| v.unwrap_or(0.0) as f32);
let offset = match encoding {
@@ -674,7 +678,7 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode, limits: &Limits) -> Result<RawIma
cinema: Default::default(),
lens_metadata: Default::default(),
level_sources: crate::LevelSources { black: black_source, white: white_source },
notices: crate::RawNotices::default(),
notices: crate::RawNotices { assumed_cfa, ..Default::default() },
};
img.validate_for(mode)?;
Ok(img)
@@ -1073,6 +1077,35 @@ mod tests {
}
}
#[test]
fn cfa_fallback_provenance_preserves_pixels_in_header_and_full_modes() {
let pixels: Vec<u16> = (0..72).map(|i| 17 + i * 113).collect();
let payload = pack(&pixels, 14);
for (code, expected, assumed) in [
(None, "RGGB", true),
(Some(0), "RGGB", true),
(Some(5), "RGGB", true),
(Some(u16::MAX), "RGGB", true),
(Some(1), "RGGB", false),
(Some(2), "GRBG", false),
(Some(3), "GBRG", false),
(Some(4), "BGGR", false),
] {
let mut tags = vec![short(BITS, 14), short(RAW_FORMAT, 7)];
if let Some(code) = code {
tags.push(short(CFA_PATTERN, code));
}
let bytes = file(18, 4, &tags, &payload, &|off| vec![(RAW_OFFSET, Value::Long(vec![off]))]);
for mode in [Mode::Header, Mode::Full] {
let image = decode(&bytes, mode, &Limits::default()).unwrap();
assert_eq!((image.width, image.height), (18, 4));
assert_eq!(image.cfa.as_ref().unwrap().name(), expected, "code {code:?}");
assert_eq!(image.notices, crate::RawNotices { assumed_cfa: assumed, ..Default::default() }, "code {code:?}, {mode:?}");
assert_eq!(samples(&image), if mode == Mode::Full { pixels.as_slice() } else { &[] });
}
}
}
#[test]
fn lossless_packed_formats_preserve_zero_codes_inside_the_active_area() {
let (w, h) = (90usize, 12usize);
+15
View File
@@ -462,9 +462,24 @@ fn embedded(used: &Used, limits: &Limits, data: &[u8], options: &usvg::Options<'
return None;
}
};
// The raw/inflated bytes can fit while UTF-16/Latin-1 decoding expands
// beyond the aggregate allowance. A refusal consumes the remaining work.
if text.len() > left {
used.bytes.fetch_add(left, Ordering::Relaxed);
used.svg_limit.fetch_add(1, Ordering::Relaxed);
used.svg_resource_limit.fetch_add(1, Ordering::Relaxed);
return None;
}
used.bytes.fetch_add(text.len(), Ordering::Relaxed);
let xml = match checked(&text, limits) {
Ok(xml) => xml,
// Decoding UTF-16 or Latin-1 can exceed the text cap after the
// raw/inflated bytes fitted. This is a resource refusal, not invalid XML.
Err(Error::Text(svgz::Error::TooLarge(_))) => {
used.svg_limit.fetch_add(1, Ordering::Relaxed);
used.svg_resource_limit.fetch_add(1, Ordering::Relaxed);
return None;
}
Err(_) => {
used.invalid_svg.fetch_add(1, Ordering::Relaxed);
return None;
+87
View File
@@ -269,6 +269,93 @@ mod resource_limit_usage {
(found, resolver.usage())
}
fn expanding_encoded_children() -> Vec<(&'static str, Vec<u8>)> {
let latin =
format!("<?xml version='1.0' encoding='ISO-8859-1'?>{}", svg(&format!("<title>{}</title><rect width='1' height='1'/>", "é".repeat(100))));
let latin = latin.chars().map(|c| u8::try_from(u32::from(c)).unwrap()).collect();
let wide = svg(&format!("<title>{}</title><rect width='1' height='1'/>", "ࠀ".repeat(400)));
let mut little = vec![0xff, 0xfe];
little.extend(wide.encode_utf16().flat_map(u16::to_le_bytes));
let mut big = vec![0xfe, 0xff];
big.extend(wide.encode_utf16().flat_map(u16::to_be_bytes));
vec![("Latin-1", latin), ("UTF-16LE", little), ("UTF-16BE", big)]
}
#[test]
fn decoded_text_expansion_is_a_resource_refusal_for_plain_and_gzip_children() {
for (encoding, raw) in expanding_encoded_children() {
let decoded = svgz::decode(&raw).unwrap();
let cap = raw.len();
assert!(decoded.len() > cap, "{encoding} fixture must expand after inflation");
for gzip in [false, true] {
let data = if gzip { svgz::compress(&raw) } else { raw.clone() };
assert_eq!(svgz::inflate(&data, cap).unwrap().len(), cap, "raw bytes fit exactly");
assert_eq!(svgz::text(&data, cap).unwrap().len(), decoded.len(), "decoding itself succeeds");
let limits = Limits { bytes: cap, embedded_bytes: decoded.len(), ..shallow() };
assert!(matches!(checked(&decoded, &limits), Err(Error::Text(svgz::Error::TooLarge(n))) if n == cap));
let image = data_image(&data);
let (found, usage) = resolved(&svg(&image), limits, 1);
assert!(found.is_empty(), "{encoding}, gzip {gzip}");
assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images, usage.invalid_svg_images), (1, 1, 0));
assert_eq!(usage.embedded_svg_bytes, decoded.len(), "spent decoded work remains charged");
let (found, usage) = resolved(&svg(&format!("{image}{image}")), limits, 1);
assert!(found.is_empty());
assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images, usage.invalid_svg_images), (2, 2, 0));
assert_eq!(usage.embedded_svg_bytes, decoded.len(), "a refused sibling cannot repeat exhausted work");
}
}
}
#[test]
fn decoded_text_expansion_respects_aggregate_bytes_even_when_each_child_fits() {
for (encoding, raw) in expanding_encoded_children() {
let decoded = svgz::decode(&raw).unwrap();
let limits = Limits { bytes: decoded.len(), embedded_bytes: raw.len(), ..shallow() };
assert!(decoded.len() > limits.embedded_bytes);
checked(&decoded, &limits).unwrap(); // The independent per-image cap allows this complete XML.
for gzip in [false, true] {
let data = if gzip { svgz::compress(&raw) } else { raw.clone() };
assert_eq!(svgz::inflate(&data, limits.embedded_bytes).unwrap().len(), raw.len());
let image = data_image(&data);
let (found, usage) = resolved(&svg(&image), limits, 1);
assert!(found.is_empty(), "{encoding}, gzip {gzip}");
assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images, usage.invalid_svg_images), (1, 1, 0));
assert_eq!(usage.embedded_svg_bytes, limits.embedded_bytes, "refusal consumes exactly the remaining allowance");
let (found, usage) = resolved(&svg(&format!("{image}{image}")), limits, 1);
assert!(found.is_empty());
assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images, usage.invalid_svg_images), (2, 2, 0));
assert_eq!(usage.embedded_svg_bytes, limits.embedded_bytes, "a later child cannot repeat exhausted work");
let (found, usage) = resolved(&svg(&image), Limits { embedded_bytes: decoded.len(), ..limits }, 1);
assert_eq!(found, [true]);
assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images, usage.invalid_svg_images), (0, 0, 0));
assert_eq!(usage.embedded_svg_bytes, decoded.len());
}
}
}
#[test]
fn decoded_text_expansion_at_the_cap_is_valid_and_malformed_xml_stays_invalid() {
for (encoding, raw) in expanding_encoded_children() {
let decoded = svgz::decode(&raw).unwrap();
for gzip in [false, true] {
let data = if gzip { svgz::compress(&raw) } else { raw.clone() };
let limits = Limits { bytes: decoded.len(), embedded_bytes: decoded.len(), ..shallow() };
let (found, usage) = resolved(&svg(&data_image(&data)), limits, 1);
assert_eq!(found, [true], "{encoding}, gzip {gzip}");
assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images, usage.invalid_svg_images), (0, 0, 0));
assert_eq!(usage.embedded_svg_bytes, decoded.len());
// Preserve the declared/BOM encoding when making the XML malformed;
// re-encoding Latin-1 text as UTF-8 would test a second expansion instead.
let closing_bytes = if encoding == "Latin-1" { 6 } else { 12 };
let malformed = &raw[..raw.len() - closing_bytes];
let data = if gzip { svgz::compress(malformed) } else { malformed.to_vec() };
let (found, usage) = resolved(&svg(&data_image(&data)), limits, 1);
assert!(found.is_empty());
assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images, usage.invalid_svg_images), (0, 0, 1));
}
}
}
#[test]
fn embedded_chain_caps_are_explicit_resource_refusals_for_plain_and_gzip_children() {
for gzip in [false, true] {