/// Settings passed to decoders on creation
pub struct DecoderConfig {
 limits: crate::Limits, // ... and maybe more in the future
}
pub trait ImageDecoder {
 /// Returns the layout of this image, as read by [`ImageDecoder::read_image`].
 fn layout(&self) -> ImageLayout;
 /// Returns the image into the given buffer.
 ///
 /// If the image file contains multiple images/frames, the decoder will
 /// read the one that best represents the image file. For animations, this
 /// is usually the first frame.
 fn read_image(&mut self, buf: &mut [u8]) -> ImageResult<()>;
 /// If the image is a sequence of images/frames, return a decoder for the sequence.
 ///
 /// If None is returned, the image is a single image or the decoder does not
 /// support sequences decoding.
 fn as_sequence_decoder(&mut self) -> Option<&mut dyn ImageSequenceDecoder> {
 None
 }
 // ... metadata stuff
}
#[non_exhaustive]
pub enum SequenceKind {
 /// A sequence of unknown or unspecified semantics.
 Sequence,
 /// An animation sequence.
 Animation {
 // ... animation info
 looping: (), // no/yes how many times
 frame_rate: (),
 },
 /// A volume represented by a sequence of 2D slices
 Volume,
} 
pub trait ImageSequenceDecoder {
 /// The semantics of the sequence.
 fn kind(&self) -> SequenceKind;
 /// The total number of elements in the sequence
 fn count(&self) -> u32;
 // ... other sequence related info
 /// Returns the layout of the next frame in the sequence, or None if there are no more frames.
 fn read_next_frame_layout(&mut self) -> ImageResult<Option<ImageLayout>>;
 fn read_next_frame(&mut self, buf: &[u8]) -> ImageResult<()>;
 fn skip_next_frame(&mut self) -> ImageResult<()>;
}

// define the configuration for the decoder (or just use DecoderConfig::default())
let mut config = DecoderConfig::default();
config.set_limit(...);
// create the decoder, which reads enough of the file to implement the ImageDecoder interface
let mut decoder = MyDecoder::new(reader, config)?;
// now we can ask it for dimensions, color, metadata an so on.
let (width, height) = decoder.layout().size();
// read the image file as a single image
let mut image = alloc_image(decoder.layout()); // allocate mem for the image
decoder.read_image(&mut image.buf)?;

let mut decoder = MyDecoder::new(reader, Default::default())?;
// now we ask it to treat the image as a sequence
let mut sequence_decoder = decoder.as_sequence_decoder().expect("not a sequence!");
dbg!(sequence_decoder.kind()); // could be SeqKind::Animation { looping: inf. frame_delay: 100ms }
dbg!(sequence_decoder.count()); // could be 12 for an animation with 12 frames
while let Some(frame_layout) = sequence_decoder.read_next_frame_layout()? {
 let mut image = alloc_image(frame_layout); // allocate mem for the image
 sequence_decoder.read_next_frame(&mut image.buf)?;
 do_something_with(image);
}

pub struct FrameIterator<'a> {
 decoder: &'a mut dyn ImageSequenceDecoder,
}
impl<'a> FrameIterator<'a> {
 pub fn new(decoder: &'a mut dyn ImageSequenceDecoder) -> Self {
 Self { decoder }
 }
}
impl<'a> Iterator for FrameIterator<'a> {
 type Item = ImageResult<DynamicImage>;
 fn next(&mut self) -> Option<Self::Item> {
 let layout = match self.decoder.read_next_frame_layout() {
 Ok(Some(layout)) => layout,
 Ok(None) => return None,
 Err(e) => return Some(Err(e)),
 };
 let mut image = alloc_image(frame_layout);
 self.decoder.read_next_frame(&mut image.buf)?;
 Some(Ok(image))
 }
}