use crate::error::{ImageFormatHint, ImageResult, UnsupportedError, UnsupportedErrorKind};
use crate::{ColorType, DynamicImage, ExtendedColorType};
/// Nominally public but DO NOT expose this type.
///
/// To be somewhat sure here's a compile fail test:
///
/// ```compile_fail
/// use image::MethodSealedToImage;
/// ```
///
/// ```compile_fail
/// use image::io::MethodSealedToImage;
/// ```
///
/// The same implementation strategy for a partially public trait is used in the standard library,
/// for the different effect of forbidding `Error::type_id` overrides thus making them reliable for
/// their calls through the `dyn` version of the trait.
///
/// Read more:
#[derive(Clone, Copy)]
pub struct MethodSealedToImage;
/// The trait all encoders implement
pub trait ImageEncoder {
/// Writes all the bytes in an image to the encoder.
///
/// This function takes a slice of bytes of the pixel data of the image
/// and encodes them. Just like for [`ImageDecoder::read_image`], no particular
/// alignment is required and data is expected to be in native endian.
/// The implementation will reorder the endianness as necessary for the target encoding format.
///
/// # Panics
///
/// Panics if `width * height * color_type.bytes_per_pixel() != buf.len()`.
fn write_image(
self,
buf: &[u8],
width: u32,
height: u32,
color_type: ExtendedColorType,
) -> ImageResult<()>;
/// Set the ICC profile to use for the image.
///
/// This function is a no-op for formats that don't support ICC profiles.
/// For formats that do support ICC profiles, the profile will be embedded
/// in the image when it is saved.
///
/// # Errors
///
/// This function returns an error if the format does not support ICC profiles.
fn set_icc_profile(&mut self, icc_profile: Vec) -> Result<(), UnsupportedError> {
let _ = icc_profile;
Err(UnsupportedError::from_format_and_kind(
ImageFormatHint::Unknown,
UnsupportedErrorKind::GenericFeature(
"ICC profiles are not supported for this format".into(),
),
))
}
/// Set the EXIF metadata to use for the image.
///
/// This function is a no-op for formats that don't support EXIF metadata.
/// For formats that do support EXIF metadata, the metadata will be embedded
/// in the image when it is saved.
///
/// # Errors
///
/// This function returns an error if the format does not support EXIF metadata or if the
/// encoder doesn't implement saving EXIF metadata yet.
fn set_exif_metadata(&mut self, exif: Vec) -> Result<(), UnsupportedError> {
let _ = exif;
Err(UnsupportedError::from_format_and_kind(
ImageFormatHint::Unknown,
UnsupportedErrorKind::GenericFeature(
"EXIF metadata is not supported for this format".into(),
),
))
}
/// Convert the image to a compatible format for the encoder. This is used by the encoding
/// methods on `DynamicImage`.
///
/// Note that this is method is sealed to the crate and effectively pub(crate) due to the
/// argument type not being nameable.
#[doc(hidden)]
fn make_compatible_img(
&self,
_: MethodSealedToImage,
_input: &DynamicImage,
) -> Option {
None
}
}
pub(crate) trait ImageEncoderBoxed: ImageEncoder {
fn write_image(
self: Box,
buf: &'_ [u8],
width: u32,
height: u32,
color: ExtendedColorType,
) -> ImageResult<()>;
}
impl ImageEncoderBoxed for T {
fn write_image(
self: Box,
buf: &'_ [u8],
width: u32,
height: u32,
color: ExtendedColorType,
) -> ImageResult<()> {
(*self).write_image(buf, width, height, color)
}
}
/// Implement `dynimage_conversion_sequence` for the common case of supporting only 8-bit colors
/// (with and without alpha).
#[allow(unused)]
pub(crate) fn dynimage_conversion_8bit(img: &DynamicImage) -> Option {
use ColorType::*;
match img.color() {
Rgb8 | Rgba8 | L8 | La8 => None,
L16 => Some(img.to_luma8().into()),
La16 => Some(img.to_luma_alpha8().into()),
Rgb16 | Rgb32F => Some(img.to_rgb8().into()),
Rgba16 | Rgba32F => Some(img.to_rgba8().into()),
}
}