diff --git a/mp4parse/src/lib.rs b/mp4parse/src/lib.rs index ca110f60..5355d325 100644 --- a/mp4parse/src/lib.rs +++ b/mp4parse/src/lib.rs @@ -2000,9 +2000,9 @@ enum ConstructionMethod { /// Describes a region where a item specified by an `ItemLocationBoxItem` is stored. /// The offset is `u64` since that's the maximum possible size and since the relative /// nature of `DataBox` means this can still possibly succeed even in the case -/// that the raw value exceeds std::usize::MAX on platforms where that type is smaller +/// that the raw value exceeds usize::MAX on platforms where that type is smaller /// than u64. However, `len` is stored as a `usize` since no value larger than -/// `std::usize::MAX` can be used in a successful indexing operation in rust. +/// `usize::MAX` can be used in a successful indexing operation in rust. /// `extent_index` is omitted since it's only used for ConstructionMethod::Item which /// is currently not implemented. #[derive(Clone, Debug)] @@ -4338,7 +4338,7 @@ fn parse_mdhd( )> { let mdhd = read_mdhd(f)?; let duration = match mdhd.duration { - std::u64::MAX => None, + u64::MAX => None, duration => Some(TrackScaledTime::(duration, track.id)), }; if mdhd.timescale == 0 { @@ -4509,8 +4509,8 @@ fn read_mvhd(src: &mut BMFFBox) -> Result { 1 => be_u64(src)?, 0 => { let d = be_u32(src)?; - if d == std::u32::MAX { - std::u64::MAX + if d == u32::MAX { + u64::MAX } else { u64::from(d) } @@ -4636,8 +4636,8 @@ fn read_mdhd(src: &mut BMFFBox) -> Result { // upcasting, we need to preserve the special all-1s // ("unknown") case by hand. let d = be_u32(src)?; - if d == std::u32::MAX { - std::u64::MAX + if d == u32::MAX { + u64::MAX } else { u64::from(d) } @@ -6291,10 +6291,10 @@ mod media_data_box_tests { #[test] fn extent_with_length_which_overflows_usize() { - let mdat = DataBox::at_offset(std::u64::MAX - 1, vec![1; 5]); + let mdat = DataBox::at_offset(u64::MAX - 1, vec![1; 5]); let extent = Extent::WithLength { - offset: std::u64::MAX, - len: std::usize::MAX, + offset: u64::MAX, + len: usize::MAX, }; assert!(mdat.get(&extent).is_none()); @@ -6304,10 +6304,8 @@ mod media_data_box_tests { // because the range end is unbounded, we don't calculate it. #[test] fn extent_to_end_which_overflows_usize() { - let mdat = DataBox::at_offset(std::u64::MAX - 1, vec![1; 5]); - let extent = Extent::ToEnd { - offset: std::u64::MAX, - }; + let mdat = DataBox::at_offset(u64::MAX - 1, vec![1; 5]); + let extent = Extent::ToEnd { offset: u64::MAX }; assert_eq!(mdat.get(&extent), Some(&[1, 1, 1, 1][..])); } diff --git a/mp4parse/src/tests.rs b/mp4parse/src/tests.rs index 3eb95f0e..964d4f77 100644 --- a/mp4parse/src/tests.rs +++ b/mp4parse/src/tests.rs @@ -59,7 +59,7 @@ where BoxSize::Long(size) => assert_eq!(size, section.size()), BoxSize::Auto => { assert!( - section.size() <= u64::from(u32::max_value()), + section.size() <= u64::from(u32::MAX), "Tried to use a long box with BoxSize::Auto" ); box_size.set_const(section.size()); @@ -335,7 +335,7 @@ fn read_mdhd_unknown_duration() { s.B32(0) .B32(0) .B32(1234) // timescale - .B32(::std::u32::MAX) // duration + .B32(u32::MAX) // duration .B32(0) }); let mut iter = super::BoxIter::new(&mut stream); @@ -344,7 +344,7 @@ fn read_mdhd_unknown_duration() { assert_eq!(stream.head.size, 32); let parsed = super::read_mdhd(&mut stream).unwrap(); assert_eq!(parsed.timescale, 1234); - assert_eq!(parsed.duration, ::std::u64::MAX); + assert_eq!(parsed.duration, u64::MAX); } #[test] @@ -411,7 +411,7 @@ fn read_mvhd_unknown_duration() { s.B32(0) .B32(0) .B32(1234) - .B32(::std::u32::MAX) + .B32(u32::MAX) .append_repeated(0, 80) }); let mut iter = super::BoxIter::new(&mut stream); @@ -420,7 +420,7 @@ fn read_mvhd_unknown_duration() { assert_eq!(stream.head.size, 108); let parsed = super::read_mvhd(&mut stream).unwrap(); assert_eq!(parsed.timescale, 1234); - assert_eq!(parsed.duration, ::std::u64::MAX); + assert_eq!(parsed.duration, u64::MAX); } #[test] @@ -1361,6 +1361,6 @@ fn read_to_end_() { #[test] fn read_to_end_oom() { - let mut src = b"1234567890".take(std::isize::MAX.try_into().expect("isize < u64")); + let mut src = b"1234567890".take(isize::MAX.try_into().expect("isize < u64")); assert!(src.read_into_try_vec().is_err()); } diff --git a/mp4parse/tests/overflow.rs b/mp4parse/tests/overflow.rs index ce5dc522..398675eb 100644 --- a/mp4parse/tests/overflow.rs +++ b/mp4parse/tests/overflow.rs @@ -5,11 +5,12 @@ // file, You can obtain one at https://mozilla.org/MPL/2.0/. #[test] +#[allow(arithmetic_overflow)] #[should_panic(expected = "attempt to add with overflow")] fn overflow_protection() { - let edge = u32::max_value(); + let edge = u32::MAX; assert_eq!(0u32, edge + 1); - let edge = u64::max_value(); + let edge = u64::MAX; assert_eq!(0u64, edge + 1); } diff --git a/mp4parse_capi/src/lib.rs b/mp4parse_capi/src/lib.rs index 142fe3c1..ebcb618c 100644 --- a/mp4parse_capi/src/lib.rs +++ b/mp4parse_capi/src/lib.rs @@ -439,7 +439,7 @@ pub struct Mp4parseIo { impl Read for Mp4parseIo { fn read(&mut self, buf: &mut [u8]) -> std::io::Result { - if buf.len() > isize::max_value() as usize { + if buf.len() > isize::MAX as usize { return Err(std::io::Error::new( std::io::ErrorKind::Other, "buf length overflow in Mp4parseIo Read impl", @@ -583,7 +583,7 @@ pub unsafe extern "C" fn mp4parse_get_track_count( let context = (*parser).context(); // Make sure the track count fits in a u32. - if context.tracks.len() > u32::max_value() as usize { + if context.tracks.len() > u32::MAX as usize { return Mp4parseStatus::Invalid; } *count = context.tracks.len() as u32; @@ -763,7 +763,7 @@ fn get_track_audio_info( match audio.codec_specific { AudioCodecSpecific::ES_Descriptor(ref esds) => { - if esds.codec_esds.len() > std::u32::MAX as usize { + if esds.codec_esds.len() > u32::MAX as usize { return Err(Mp4parseStatus::Invalid); } sample_info.extra_data.length = esds.codec_esds.len(); @@ -802,7 +802,7 @@ fn get_track_audio_info( Ok(_) => { opus_header.insert(track_index, v)?; if let Some(v) = opus_header.get(&track_index) { - if v.len() > std::u32::MAX as usize { + if v.len() > u32::MAX as usize { return Err(Mp4parseStatus::Invalid); } sample_info.codec_specific_config.length = v.len(); @@ -849,7 +849,7 @@ fn get_track_audio_info( sample_info.protected_data.skip_byte_block = tenc.skip_byte_block_count.unwrap_or(0); if let Some(ref iv_vec) = tenc.constant_iv { - if iv_vec.len() > std::u32::MAX as usize { + if iv_vec.len() > u32::MAX as usize { return Err(Mp4parseStatus::Invalid); } sample_info.protected_data.constant_iv.set_data(iv_vec); @@ -864,7 +864,7 @@ fn get_track_audio_info( .insert(track_index, audio_sample_infos)?; match parser.audio_track_sample_descriptions.get(&track_index) { Some(sample_info) => { - if sample_info.len() > std::u32::MAX as usize { + if sample_info.len() > u32::MAX as usize { // Should never happen due to upper limits on number of sample // descriptions a track can have, but lets be safe. return Err(Mp4parseStatus::Invalid); @@ -1017,7 +1017,7 @@ fn mp4parse_get_track_video_info_safe( sample_info.protected_data.skip_byte_block = tenc.skip_byte_block_count.unwrap_or(0); if let Some(ref iv_vec) = tenc.constant_iv { - if iv_vec.len() > std::u32::MAX as usize { + if iv_vec.len() > u32::MAX as usize { return Err(Mp4parseStatus::Invalid); } sample_info.protected_data.constant_iv.set_data(iv_vec); @@ -1032,7 +1032,7 @@ fn mp4parse_get_track_video_info_safe( .insert(track_index, video_sample_infos)?; match parser.video_track_sample_descriptions.get(&track_index) { Some(sample_info) => { - if sample_info.len() > std::u32::MAX as usize { + if sample_info.len() > u32::MAX as usize { // Should never happen due to upper limits on number of sample // descriptions a track can have, but lets be safe. return Err(Mp4parseStatus::Invalid); @@ -1185,7 +1185,7 @@ fn mp4parse_avif_get_info_safe(context: &AvifContext) -> mp4parse::Result { + Some(movie_duration) if movie_duration == u64::MAX => { (Mp4parseAvifLoopMode::LoopInfinitely, 0) } Some(movie_duration) => match color_track.looped { diff --git a/mp4parse_capi/tests/test_avis.rs b/mp4parse_capi/tests/test_avis.rs index a6e5a1c6..cffd4445 100644 --- a/mp4parse_capi/tests/test_avis.rs +++ b/mp4parse_capi/tests/test_avis.rs @@ -57,7 +57,7 @@ fn check_loop_count(path: &str, expected_loop_count: i64) { Mp4parseAvifLoopMode::LoopByCount => { assert_eq!(info.loop_count.to_i64(), Some(expected_loop_count)) } - Mp4parseAvifLoopMode::LoopInfinitely => assert_eq!(expected_loop_count, std::i64::MIN), + Mp4parseAvifLoopMode::LoopInfinitely => assert_eq!(expected_loop_count, i64::MIN), } unsafe { mp4parse_avif_free(parser) }; @@ -95,7 +95,7 @@ fn loop_four_times_due_to_ceiling() { #[test] fn loop_forever() { - check_loop_count("tests/loop_forever.avif", std::i64::MIN); + check_loop_count("tests/loop_forever.avif", i64::MIN); } #[test] diff --git a/mp4parse_capi/tests/test_sample_table.rs b/mp4parse_capi/tests/test_sample_table.rs index 820eed64..0da4c02c 100644 --- a/mp4parse_capi/tests/test_sample_table.rs +++ b/mp4parse_capi/tests/test_sample_table.rs @@ -156,7 +156,7 @@ fn parse_sample_table_with_elst() { assert_eq!(track_info.track_type, Mp4parseTrackType::Audio); // Check audio sample table - let mut is_fragmented_file: u8 = std::u8::MAX; + let mut is_fragmented_file: u8 = u8::MAX; rv = mp4parse_is_fragmented(parser, track_info.track_id, &mut is_fragmented_file); assert_eq!(rv, Mp4parseStatus::Ok); assert_eq!(is_fragmented_file, 0); @@ -225,7 +225,7 @@ fn parse_sample_table_with_negative_ctts() { assert_eq!(rv, Mp4parseStatus::Ok); assert_eq!(track_info.track_type, Mp4parseTrackType::Video); - let mut is_fragmented_file: u8 = std::u8::MAX; + let mut is_fragmented_file: u8 = u8::MAX; rv = mp4parse_is_fragmented(parser, track_info.track_id, &mut is_fragmented_file); assert_eq!(rv, Mp4parseStatus::Ok); assert_eq!(is_fragmented_file, 0);