#[non_exhaustive]pub struct Limits {
pub max_image_width: Option<u32>,
pub max_image_height: Option<u32>,
pub max_alloc: Option<u64>,
}
Expand description
Resource limits for decoding.
Limits can be either strict or non-strict. Non-strict limits are best-effort
limits where the library does not guarantee that limit will not be exceeded. Do note
that it is still considered a bug if a non-strict limit is exceeded.
Some of the underlying decoders do not support such limits, so one cannot
rely on these limits being supported. For strict limits, the library makes a stronger
guarantee that the limit will not be exceeded. Exceeding a strict limit is considered
a critical bug. If a decoder cannot guarantee that it will uphold a strict limit, it
must fail with error::LimitErrorKind::Unsupported
.
The only currently supported strict limits are the max_image_width
and max_image_height
limits, but more will be added in the future. LimitSupport
will default to support
being false, and decoders should enable support for the limits they support in
ImageDecoder::set_limits
.
The limit check should only ever fail if a limit will be exceeded or an unsupported strict limit is used.
Fields (Non-exhaustive)§
This struct is marked as non-exhaustive
Struct { .. }
syntax; cannot be matched against without a wildcard ..
; and struct update syntax will not work.max_image_width: Option<u32>
The maximum allowed image width. This limit is strict. The default is no limit.
max_image_height: Option<u32>
The maximum allowed image height. This limit is strict. The default is no limit.
max_alloc: Option<u64>
The maximum allowed sum of allocations allocated by the decoder at any one time excluding allocator overhead. This limit is non-strict by default and some decoders may ignore it. The bytes required to store the output image count towards this value. The default is 512MiB.
Implementations§
source§impl Limits
impl Limits
sourcepub fn check_support(&self, _supported: &LimitSupport) -> ImageResult<()>
pub fn check_support(&self, _supported: &LimitSupport) -> ImageResult<()>
This function checks that all currently set strict limits are supported.
sourcepub fn check_dimensions(&self, width: u32, height: u32) -> ImageResult<()>
pub fn check_dimensions(&self, width: u32, height: u32) -> ImageResult<()>
This function checks the max_image_width
and max_image_height
limits given
the image width and height.
sourcepub fn reserve(&mut self, amount: u64) -> ImageResult<()>
pub fn reserve(&mut self, amount: u64) -> ImageResult<()>
This function checks that the current limit allows for reserving the set amount of bytes, it then reduces the limit accordingly.
sourcepub fn reserve_usize(&mut self, amount: usize) -> ImageResult<()>
pub fn reserve_usize(&mut self, amount: usize) -> ImageResult<()>
This function acts identically to reserve
, but takes a usize
for convenience.
sourcepub fn reserve_buffer(
&mut self,
width: u32,
height: u32,
color_type: ColorType
) -> ImageResult<()>
pub fn reserve_buffer( &mut self, width: u32, height: u32, color_type: ColorType ) -> ImageResult<()>
This function acts identically to reserve
, but accepts the width, height and color type
used to create an ImageBuffer
and does all the math for you.
sourcepub fn free(&mut self, amount: u64)
pub fn free(&mut self, amount: u64)
This function increases the max_alloc
limit with amount. Should only be used
together with reserve
.
sourcepub fn free_usize(&mut self, amount: usize)
pub fn free_usize(&mut self, amount: usize)
This function acts identically to free
, but takes a usize
for convenience.