use crate::Error;
use crate::converter::DEPENDENCIES;
use crate::converter::png::{
CompressionType, FilterType, convert_compression_type_to_ext, convert_filter_type_to_ext,
};
use crate::format::ImageFormat;
use crate::input::AnimationData;
use image::DynamicImage;
use image::metadata::LoopCount;
use std::borrow::Cow;
use std::io::Write;
use std::time::Duration;
const STILL_FRAME_DELAY_MS: u32 = 100;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct ApngOptions {
pub compression_type: Option<CompressionType>,
pub filter_type: Option<FilterType>,
}
pub struct ApngEncoder {
pub options: ApngOptions,
}
impl ApngEncoder {
pub fn new(options: ApngOptions) -> Self {
ApngEncoder { options }
}
}
impl super::ImageEncoder for ApngEncoder {
fn format(&self) -> ImageFormat {
ImageFormat::Apng
}
fn extension(&self) -> &'static str {
"png"
}
fn describe(&self) -> String {
format!(
"animated PNG (APNG) encoder (png {})",
super::dependency_version("png")
)
}
fn describe_options(&self) -> String {
encoder_info()
}
fn supports_animation(&self) -> bool {
true
}
fn encode_still_image(&self, image: &DynamicImage) -> Result<Vec<u8>, Error> {
encode_apng(&still_animation(image), self.options, None)
}
fn encode_still_image_with_metadata(
&self,
image: &DynamicImage,
metadata: &crate::metadata::ImageMetadata,
) -> Result<Vec<u8>, Error> {
encode_apng(
&still_animation(image),
self.options,
metadata.exif.as_deref(),
)
}
fn encode(&self, input: &crate::input::SourceImage) -> Result<Vec<u8>, Error> {
match &input.content {
crate::input::ImageContent::Still(image) => {
self.encode_still_image_with_metadata(image, &input.metadata)
}
crate::input::ImageContent::Animated(animation) => {
encode_apng(animation, self.options, input.metadata.exif.as_deref())
}
}
}
}
fn still_animation(image: &DynamicImage) -> AnimationData {
AnimationData {
width: image.width(),
height: image.height(),
frames: vec![crate::input::FrameData {
buffer: image.to_rgba8(),
delay: Duration::from_millis(u64::from(STILL_FRAME_DELAY_MS)),
}],
loop_count: LoopCount::Infinite,
}
}
impl ApngEncoder {
pub fn encode_animation(
&self,
animation: &AnimationData,
exif_payload: Option<&[u8]>,
) -> Result<Vec<u8>, Error> {
encode_apng(animation, self.options, exif_payload)
}
}
fn encode_apng(
animation: &AnimationData,
options: ApngOptions,
exif_payload: Option<&[u8]>,
) -> Result<Vec<u8>, Error> {
if animation.width == 0 || animation.height == 0 {
return Err(Error::from_string(
"APNG encoding requires non-zero dimensions".to_string(),
));
}
let num_plays = match animation.loop_count {
LoopCount::Infinite => 0,
LoopCount::Finite(n) => n.get(),
};
let mut output = Vec::new();
let mut info = png::Info::with_size(animation.width, animation.height);
if let Some(exif) = exif_payload {
info.exif_metadata = Some(Cow::Borrowed(exif));
}
let mut encoder = png::Encoder::with_info(&mut output, info)
.map_err(|e| Error::from_string(format!("apng encoding failed: {e:?}")))?;
encoder.set_color(png::ColorType::Rgba);
encoder.set_depth(png::BitDepth::Eight);
encoder.set_compression(convert_compression_type_to_ext(options.compression_type));
encoder.set_filter(convert_filter_type_to_ext(options.filter_type));
encoder
.set_animated(animation.frames.len() as u32, num_plays)
.map_err(|e| Error::from_string(format!("apng encoding failed: {e:?}")))?;
encoder
.set_sep_def_img(true)
.map_err(|e| Error::from_string(format!("apng encoding failed: {e:?}")))?;
let mut writer = encoder
.write_header()
.map_err(|e| Error::from_string(format!("apng encoding failed: {e:?}")))?;
let first = animation
.frames
.first()
.ok_or_else(|| Error::from_string("APNG requires at least one frame".to_string()))?;
writer
.write_image_data(first.buffer.as_raw())
.map_err(|e| Error::from_string(format!("apng encoding failed: {e:?}")))?;
for frame in &animation.frames {
let (delay_num, delay_den) = frame_delay_fraction(frame.delay);
writer
.set_frame_delay(delay_num, delay_den)
.map_err(|e| Error::from_string(format!("apng encoding failed: {e:?}")))?;
writer
.write_image_data(frame.buffer.as_raw())
.map_err(|e| Error::from_string(format!("apng encoding failed: {e:?}")))?;
}
writer
.finish()
.map_err(|e| Error::from_string(format!("apng encoding failed: {e:?}")))?;
let _ = output.flush();
Ok(output)
}
fn frame_delay_fraction(delay: Duration) -> (u16, u16) {
let ms = delay.as_millis().min(u16::MAX as u128) as u16;
(ms, 1000)
}
fn encoder_info() -> String {
let mut png_version = "";
match DEPENDENCIES.iter().rfind(|&&(name, _)| name == "png") {
Some((_name, version)) => png_version = version,
None => println!("Package 'png' not found"),
};
format!("Using \"png\" ({png_version}) in animated (APNG) mode")
}