diff --git a/src/bounded/grid.rs b/src/bounded/grid.rs index 43f17d6..799a44e 100644 --- a/src/bounded/grid.rs +++ b/src/bounded/grid.rs @@ -161,6 +161,11 @@ impl<'a> Properties<'a> { _ => {} } if let Some(transform) = transform { + if result.transforms.iter().flatten().any(|stored| { + std::mem::discriminant(stored) == std::mem::discriminant(&transform) + }) { + return Err(Error::Malformed("duplicate transform property")); + } if result.transform_count == result.transforms.len() { return Err(Error::LimitExceeded("transform count")); } diff --git a/src/bounded/tests.rs b/src/bounded/tests.rs index 8f7fc65..bc71c6e 100644 --- a/src/bounded/tests.rs +++ b/src/bounded/tests.rs @@ -57,13 +57,23 @@ fn fixture_with_exif( extra_properties: &[Vec], orientation: Option, ) -> Vec { - fixture_with_exif_info(configs, payload, extra_properties, orientation, b"Exif\0") + fixture_with_exif_info( + configs, + payload, + extra_properties, + &(0..extra_properties.len()).collect::>(), + &[], + orientation, + b"Exif\0", + ) } fn fixture_with_exif_info( configs: &[Vec], payload: &[u8], extra_properties: &[Vec], + primary_extras: &[usize], + tile_extras: &[usize], orientation: Option, exif_info: &[u8], ) -> Vec { @@ -109,13 +119,20 @@ fn fixture_with_exif_info( ); associations.extend_from_slice(&id.to_be_bytes()); if id == primary { - associations.push(1 + extra_properties.len() as u8); + associations.push(1 + primary_extras.len() as u8); associations.push(0x82); - for i in 0..extra_properties.len() { + for i in primary_extras { associations.push(0x80 | (3 + configs.len() + i) as u8); } } else { - associations.extend_from_slice(&[2, 0x81, 0x80 | (id + 2) as u8]); + associations.extend_from_slice(&[ + 2 + tile_extras.len() as u8, + 0x81, + 0x80 | (id + 2) as u8, + ]); + for i in tile_extras { + associations.push(0x80 | (3 + configs.len() + i) as u8); + } } } let mut exif = Vec::new(); @@ -755,18 +772,28 @@ fn incremental_rejects_unimplemented_chroma_transform_orders() { .into_iter() .flat_map(u32::to_be_bytes) .collect::>(); - for extras in [ - vec![box_bytes(b"irot", &[1]), box_bytes(b"clap", &crop)], - vec![box_bytes(b"clap", &crop), box_bytes(b"clap", &crop)], - ] { - let bytes = fixture(std::slice::from_ref(&config), &nals[3], &extras); - assert!(matches!( - incremental::decode(BoundedInput::Bytes(&bytes), Default::default()), - Err(BoundedDecodeError::Unsupported( - "repeated crop or crop after orientation" - )) - )); - } + let bytes = fixture( + std::slice::from_ref(&config), + &nals[3], + &[box_bytes(b"irot", &[1]), box_bytes(b"clap", &crop)], + ); + assert!(matches!( + incremental::decode(BoundedInput::Bytes(&bytes), Default::default()), + Err(BoundedDecodeError::Unsupported( + "repeated crop or crop after orientation" + )) + )); + let bytes = fixture( + std::slice::from_ref(&config), + &nals[3], + &[box_bytes(b"clap", &crop), box_bytes(b"clap", &crop)], + ); + assert!(matches!( + incremental::decode(BoundedInput::Bytes(&bytes), Default::default()), + Err(BoundedDecodeError::Malformed( + "duplicate transform property" + )) + )); let bytes = fixture( &[config.clone(), config], &nals[3], @@ -1006,6 +1033,8 @@ fn public_decode_applies_associated_exif_after_identity_rotation() { &[config.clone(), config.clone()], &asymmetric_payload(), &[box_bytes(b"irot", &[0])], + &[0], + &[], Some(orientation), exif_info, ); @@ -1123,6 +1152,64 @@ fn render_rejects_workspace_and_geometry_changes_after_preflight() { )); } +#[cfg(not(feature = "decoder-tracing"))] +#[test] +fn rejects_repeated_transform_types_like_normal_decode() { + let nals = nal_sets(); + let config = configuration(&nals[1]); + let crop: Vec<_> = [13u32, 1, 11, 1, 0, 1, 0, 1] + .into_iter() + .flat_map(u32::to_be_bytes) + .collect(); + let mirror = box_bytes(b"imir", &[0]); + let rotation = box_bytes(b"irot", &[1]); + let identity = box_bytes(b"irot", &[0]); + let clean_aperture = box_bytes(b"clap", &crop); + for (properties, primary_extras, tile_extras) in [ + (vec![mirror.clone()], vec![0, 0], vec![]), + (vec![mirror.clone(), mirror], vec![0, 1], vec![]), + (vec![rotation.clone()], vec![0, 0], vec![]), + (vec![identity.clone(), rotation], vec![0, 1], vec![]), + (vec![clean_aperture.clone()], vec![0, 0], vec![]), + ( + vec![clean_aperture.clone(), clean_aperture], + vec![0, 1], + vec![], + ), + (vec![identity.clone()], vec![], vec![0, 0]), + (vec![identity.clone(), identity.clone()], vec![], vec![0, 1]), + ] { + let bytes = fixture_with_exif_info( + std::slice::from_ref(&config), + &nals[3], + &properties, + &primary_extras, + &tile_extras, + None, + b"Exif\0", + ); + assert!(matches!( + decode_bounded(BoundedInput::Bytes(&bytes), Default::default()), + Err(BoundedDecodeError::Malformed( + "duplicate transform property" + )) + )); + assert!(crate::decode_bytes_to_rgb8(&bytes).is_err()); + } + let bytes = fixture_with_exif_info( + std::slice::from_ref(&config), + &nals[3], + &[identity], + &[], + &[0], + None, + b"Exif\0", + ); + let normal = crate::decode_bytes_to_rgb8(&bytes).unwrap(); + let bounded = decode_bounded(BoundedInput::Bytes(&bytes), Default::default()).unwrap(); + assert_eq!(bounded.image.pixels, normal.pixels); +} + #[cfg(not(feature = "decoder-tracing"))] #[test] fn rejects_zero_clean_aperture_denominators_without_panicking() { diff --git a/src/isobmff.rs b/src/isobmff.rs index 444f64b..87f8659 100644 --- a/src/isobmff.rs +++ b/src/isobmff.rs @@ -2248,6 +2248,7 @@ pub enum ParsePrimaryItemTransformPropertiesError { ImageCleanAperture(ParseImageCleanAperturePropertyError), ImageRotation(ParseImageRotationPropertyError), ImageMirror(ParseImageMirrorPropertyError), + DuplicateTransform { item_id: u32, property_type: FourCc }, } impl Display for ParsePrimaryItemTransformPropertiesError { @@ -2262,6 +2263,13 @@ impl Display for ParsePrimaryItemTransformPropertiesError { ParsePrimaryItemTransformPropertiesError::ImageCleanAperture(err) => write!(f, "{err}"), ParsePrimaryItemTransformPropertiesError::ImageRotation(err) => write!(f, "{err}"), ParsePrimaryItemTransformPropertiesError::ImageMirror(err) => write!(f, "{err}"), + ParsePrimaryItemTransformPropertiesError::DuplicateTransform { + item_id, + property_type, + } => write!( + f, + "primary item_ID {item_id} has multiple {property_type} properties" + ), } } } @@ -2830,6 +2838,11 @@ pub enum ExtractHeicItemDataError { item_id: u32, tile_item_id: u32, }, + DuplicateGridTileTransform { + item_id: u32, + tile_item_id: u32, + property_type: FourCc, + }, GridTileAssociationCountTooLarge { item_id: u32, total: usize, @@ -2994,6 +3007,14 @@ impl Display for ExtractHeicItemDataError { f, "primary grid item_ID {item_id} tile item_ID {tile_item_id} has multiple hvcC properties" ), + ExtractHeicItemDataError::DuplicateGridTileTransform { + item_id, + tile_item_id, + property_type, + } => write!( + f, + "primary grid item_ID {item_id} tile item_ID {tile_item_id} has multiple {property_type} properties" + ), ExtractHeicItemDataError::GridTileAssociationCountTooLarge { item_id, total } => { write!( f, @@ -3358,31 +3379,44 @@ pub fn parse_primary_item_transform_properties( pub(crate) fn parse_primary_item_transform_properties_from_resolved_graph( resolved: &ResolvedPrimaryItemGraph<'_>, ) -> Result { + let mut transform_types = Vec::new(); let mut transforms = Vec::new(); for property in &resolved.primary_item.properties { let property_type = property.property.header.box_type; - if property_type.as_bytes() == CLAP_BOX_TYPE { - transforms.push(PrimaryItemTransformProperty::CleanAperture( + let transform = if property_type.as_bytes() == CLAP_BOX_TYPE { + PrimaryItemTransformProperty::CleanAperture( property .property .parse_clap() .map_err(ParsePrimaryItemTransformPropertiesError::ImageCleanAperture)?, - )); + ) } else if property_type.as_bytes() == IROT_BOX_TYPE { - transforms.push(PrimaryItemTransformProperty::Rotation( + PrimaryItemTransformProperty::Rotation( property .property .parse_irot() .map_err(ParsePrimaryItemTransformPropertiesError::ImageRotation)?, - )); + ) } else if property_type.as_bytes() == IMIR_BOX_TYPE { - transforms.push(PrimaryItemTransformProperty::Mirror( + PrimaryItemTransformProperty::Mirror( property .property .parse_imir() .map_err(ParsePrimaryItemTransformPropertiesError::ImageMirror)?, - )); + ) + } else { + continue; + }; + if transform_types.contains(&property_type) { + return Err( + ParsePrimaryItemTransformPropertiesError::DuplicateTransform { + item_id: resolved.primary_item.item_id, + property_type, + }, + ); } + transform_types.push(property_type); + transforms.push(transform); } Ok(PrimaryItemTransformProperties { @@ -4669,6 +4703,7 @@ fn resolve_grid_tile_hvcc_colr_and_transforms_indexed( let mut hvcc = None; let mut last_nclx = None; let mut last_icc = None; + let mut transform_types = Vec::new(); let mut transforms = Vec::new(); for association in associations { @@ -4704,7 +4739,24 @@ fn resolve_grid_tile_hvcc_colr_and_transforms_indexed( ColorInformation::Nclx(_) => last_nclx = Some(property_index), ColorInformation::Icc(_) => last_icc = Some(property_index), }, - CachedGridProperty::Transform(transform) => transforms.push(*transform), + CachedGridProperty::Transform(transform) => { + let property_type = property.header.box_type; + if transform_types.contains(&property_type) { + return Err(ExtractHeicItemDataError::DuplicateGridTileTransform { + item_id, + tile_item_id, + property_type, + }); + } + transform_types.push(property_type); + if !matches!( + transform, + PrimaryItemTransformProperty::Rotation(rotation) + if rotation.rotation_ccw_degrees.is_multiple_of(360) + ) { + transforms.push(*transform); + } + } CachedGridProperty::Ignored => {} } } @@ -7843,13 +7895,15 @@ mod tests { }; use super::{ ExtractHeicItemDataError, ExtractUncompressedItemDataError, FourCc, - HeicGridPrimaryItemData, HeicPrimaryItemDataWithGrid, IccColorProfile, NclxColorProfile, - ParseItemLocationBoxError, ParseItemPropertyAssociationBoxError, - PrimaryItemColorProperties, extract_primary_heic_item_data_with_grid, + HeicGridPrimaryItemData, HeicPrimaryItemDataWithGrid, IMIR_BOX_TYPE, IROT_BOX_TYPE, + IccColorProfile, NclxColorProfile, ParseItemLocationBoxError, + ParseItemPropertyAssociationBoxError, ParsePrimaryItemTransformPropertiesError, + PrimaryItemColorProperties, PrimaryItemTransformProperty, + extract_primary_heic_item_data_with_grid, extract_primary_heic_item_data_with_grid_from_source, extract_primary_uncompressed_item_data, extract_primary_uncompressed_item_data_from_source, - merge_primary_and_grid_tile_color_properties, parse_iloc_payload, parse_ipma_payload, - primary_heic_color_properties, + merge_primary_and_grid_tile_color_properties, parse_boxes, parse_iloc_payload, + parse_ipma_payload, parse_primary_item_transform_properties, primary_heic_color_properties, }; use std::sync::Arc; @@ -8248,24 +8302,18 @@ mod tests { #[test] fn grid_tile_transforms_are_shared_across_duplicate_references() { - let mut tile_property_indices = vec![1_u8]; - tile_property_indices.extend([2_u8; 254]); - let rotations = [2_u8; 255]; - let extra_rotations: Vec<(u16, &[u8])> = - (0..256).map(|_| (2_u16, &rotations[..])).collect(); - let grid = resolved_grid(&minimal_heic_grid_file( (16, 16), (64, 64), &[2_u16; 256], &[0x11; 16], &[hvcc_box(), plain_box(b"irot", &[1])], - &tile_property_indices, - &extra_rotations, + &[1, 2], + &[], )); assert_eq!(grid.tiles.len(), 256); - assert_eq!(grid.tiles[0].transforms.len(), 254 + 256 * 255); + assert_eq!(grid.tiles[0].transforms.len(), 1); assert!( grid.tiles .iter() @@ -8273,6 +8321,206 @@ mod tests { ); } + fn identity_clap_box() -> Vec { + let fields: [u32; 8] = [16, 1, 16, 1, 0, 1, 0, 1]; + plain_box( + b"clap", + &fields + .iter() + .flat_map(|field| field.to_be_bytes()) + .collect::>(), + ) + } + + #[test] + fn grid_tile_repeated_transform_associations_are_rejected() { + let mut tile_property_indices = vec![1_u8]; + tile_property_indices.extend([2_u8; 254]); + let repeats = [2_u8; 255]; + let extra_repeats: Vec<(u16, &[u8])> = (0..256).map(|_| (2_u16, &repeats[..])).collect(); + + for property in [ + identity_clap_box(), + plain_box(b"irot", &[0]), + plain_box(b"imir", &[0]), + ] { + let property_type = FourCc::new(property[4..8].try_into().unwrap()); + let err = extract_primary_heic_item_data_with_grid(&minimal_heic_grid_file( + (16, 16), + (256, 256), + &[2_u16; 256], + &[0x11; 16], + &[hvcc_box(), property], + &tile_property_indices, + &extra_repeats, + )) + .expect_err("repeated tile transform must be rejected"); + assert!( + matches!( + err, + ExtractHeicItemDataError::DuplicateGridTileTransform { + tile_item_id: 2, + property_type: actual, + .. + } if actual == property_type + ), + "{property_type}: {err}" + ); + } + } + + #[test] + fn grid_tile_distinct_properties_of_one_transform_type_are_rejected() { + let err = extract_primary_heic_item_data_with_grid(&minimal_heic_grid_file( + (1, 1), + (64, 64), + &[2], + &[0x11; 16], + &[ + hvcc_box(), + plain_box(b"irot", &[0]), + identity_clap_box(), + plain_box(b"irot", &[2]), + ], + &[1, 2, 3, 4], + &[], + )) + .expect_err("second irot must be rejected"); + assert!(matches!( + err, + ExtractHeicItemDataError::DuplicateGridTileTransform { + property_type, + .. + } if property_type.as_bytes() == IROT_BOX_TYPE + )); + } + + #[test] + fn grid_tile_transforms_keep_one_per_type_and_drop_identity_rotations() { + let grid = resolved_grid(&minimal_heic_grid_file( + (16, 16), + (256, 256), + &[2_u16; 256], + &[0x11; 16], + &[ + hvcc_box(), + plain_box(b"irot", &[0]), + identity_clap_box(), + plain_box(b"imir", &[1]), + ], + &[1, 2, 3, 4], + &[], + )); + + assert_eq!( + grid.tiles[0].transforms.as_ref(), + [ + PrimaryItemTransformProperty::CleanAperture( + parse_boxes(&identity_clap_box()).unwrap()[0] + .parse_clap() + .unwrap() + ), + PrimaryItemTransformProperty::Mirror( + parse_boxes(&plain_box(b"imir", &[1])).unwrap()[0] + .parse_imir() + .unwrap() + ), + ] + ); + } + + #[test] + fn primary_repeated_transform_associations_are_rejected() { + let repeats = [2_u8; 255]; + let extra_repeats: Vec<(u16, &[u8])> = (0..257).map(|_| (1_u16, &repeats[..])).collect(); + + for property in [ + identity_clap_box(), + plain_box(b"irot", &[0]), + plain_box(b"imir", &[0]), + ] { + let property_type = FourCc::new(property[4..8].try_into().unwrap()); + let err = parse_primary_item_transform_properties(&minimal_heic_grid_file( + (1, 1), + (16, 16), + &[2], + &[0x11; 16], + &[hvcc_box(), property], + &[1], + &extra_repeats, + )) + .expect_err("repeated primary transform must be rejected"); + assert!( + matches!( + err, + ParsePrimaryItemTransformPropertiesError::DuplicateTransform { + item_id: 1, + property_type: actual, + } if actual == property_type + ), + "{property_type}: {err}" + ); + } + } + + #[test] + fn primary_distinct_properties_of_one_transform_type_are_rejected() { + let err = parse_primary_item_transform_properties(&minimal_heic_grid_file( + (1, 1), + (16, 16), + &[2], + &[0x11; 16], + &[ + hvcc_box(), + plain_box(b"imir", &[0]), + identity_clap_box(), + plain_box(b"imir", &[1]), + ], + &[1], + &[(1, &[2, 3, 4])], + )) + .expect_err("second imir must be rejected"); + assert!(matches!( + err, + ParsePrimaryItemTransformPropertiesError::DuplicateTransform { + property_type, + .. + } if property_type.as_bytes() == IMIR_BOX_TYPE + )); + } + + #[test] + fn primary_transforms_keep_one_of_each_type_in_order() { + let transforms = parse_primary_item_transform_properties(&minimal_heic_grid_file( + (1, 1), + (16, 16), + &[2], + &[0x11; 16], + &[ + hvcc_box(), + identity_clap_box(), + plain_box(b"irot", &[0]), + plain_box(b"imir", &[1]), + ], + &[1], + &[(1, &[2, 3, 4])], + )) + .expect("one transform of each type is valid") + .transforms; + + assert_eq!( + transforms + .iter() + .map(|transform| match transform { + PrimaryItemTransformProperty::CleanAperture(_) => "clap", + PrimaryItemTransformProperty::Rotation(_) => "irot", + PrimaryItemTransformProperty::Mirror(_) => "imir", + }) + .collect::>(), + ["clap", "irot", "imir"] + ); + } + #[test] fn grid_tile_codec_configurations_are_shared_across_duplicate_references() { let nal_count = 65_535_u16;