Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp

test(media-proxy): remove media processing tests and fixtures

Hampusbb401785da1c
diff --git a/fluxer_media_proxy/src/media_process/nsfw_processing/mod.rs b/fluxer_media_proxy/src/media_process/nsfw_processing/mod.rs
index a634d2b70..4469955c1 100644
--- a/fluxer_media_proxy/src/media_process/nsfw_processing/mod.rs
+++ b/fluxer_media_proxy/src/media_process/nsfw_processing/mod.rs
@@ -416,6 +416,3 @@ pub fn encode_static_image_for_nsfw(
};
transform_image(input, &options, media_limits, metrics).map(|media| media.bytes)
}
-
-#[cfg(test)]
-mod tests;
diff --git a/fluxer_media_proxy/src/media_process/nsfw_processing/tests.rs b/fluxer_media_proxy/src/media_process/nsfw_processing/tests.rs
deleted file mode 100644
index 48cedc001..000000000
--- a/fluxer_media_proxy/src/media_process/nsfw_processing/tests.rs
+++ /dev/null
@@ -1,216 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use super::*;
-use crate::test_fixtures::{animated_gif_fixture, ffmpeg_gen_mp4};
-use base64::{Engine as _, engine::general_purpose};
-
-const APNG_FIXTURE_BASE64: &str = "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAACXBIWXMAAAABAAAAAQBPJcTWAAAACGFjVEwAAAACAAAAAPONk3AAAAAaZmNUTAAAAAAAAAAQAAAAEAAAAAAAAAAAAAEABQAAaBqIGAAAAK1JREFUeJxjqGf4hxUxIKF/DH+BiOH/fxAiU4Mcgx0aYkBCtgy2QMRgZwdCg1yDCQMvEL1oMACix00mQCTFwANE/gx8QHSrUwuI0DXsbpkCVJ3IwBDEwADUsLprLkTD2ZoeoOp8OQZgaIEQxG5IiNqCXQARQw5pqJOooCFPj+Fcn96x9gxTBpS49NBk2DwlhBoaaOkHZUOGqYvDnrWJt6kRF6xADUAE1ABEuCIOAPEY5L3Pr8FWAAAAGmZjVEwAAAABAAAAAQAAAAEAAAAAAAAAAAABAAUAAMpQnTkAAAAQZmRBVAAAAAJ4nGOoZ/gHAAJ/AX511aUxAAAAAElFTkSuQmCC";
-
-fn limits() -> MediaLimits {
- MediaLimits::default_from_config()
-}
-
-fn reconciled_frame_count(input: &[u8], media_limits: &MediaLimits) -> u32 {
- super::super::image_probe::probe_image_dims(media_limits, input)
- .expect("image dimensions")
- .pages
- .max(mime::sniff(input).frames)
-}
-
-fn assert_bounded_jpeg(frame: &[u8], media_limits: &MediaLimits) -> (u32, u32) {
- assert_eq!(&[0xFF, 0xD8], &frame[..2], "extracted frame is not a JPEG");
- assert!(
- frame.len() <= NSFW_MAX_FRAME_BYTES,
- "frame of {} bytes exceeds the classifier boundary",
- frame.len()
- );
- let dims =
- super::super::image_probe::probe_image_dims(media_limits, frame).expect("frame dimensions");
- assert!(
- dims.width.max(dims.height) <= NSFW_FRAME_MAX_DIMENSION,
- "frame {}x{} exceeds the {NSFW_FRAME_MAX_DIMENSION} px cap",
- dims.width,
- dims.height
- );
- (dims.width, dims.height)
-}
-
-#[test]
-fn video_nsfw_frames_are_downscaled_to_the_frame_cap() {
- let Some(mp4) = ffmpeg_gen_mp4(&[
- "-f",
- "lavfi",
- "-i",
- "testsrc=size=1280x720:rate=10:duration=4",
- "-pix_fmt",
- "yuv420p",
- "-f",
- "mp4",
- ]) else {
- eprintln!("skipping: ffmpeg CLI not available");
- return;
- };
- let media_limits = limits();
- let duration = super::super::probe_av_metadata(&mp4, 0, &media_limits, None)
- .expect("probe generated mp4")
- .probe
- .duration_seconds;
- let frames = extract_video_frames_for_nsfw(VideoNSFWFramesRequest {
- input: &mp4,
- duration_seconds: duration,
- deadline_ms: None,
- })
- .expect("extract nsfw frames");
- assert_eq!(MAX_NSFW_SAMPLE_FRAMES, frames.len());
- for frame in &frames {
- let (width, height) = assert_bounded_jpeg(frame, &media_limits);
- assert_eq!(
- NSFW_FRAME_MAX_DIMENSION,
- width.max(height),
- "a 1280x720 source must be fitted to the cap, got {width}x{height}"
- );
- }
-}
-
-#[test]
-fn the_video_scan_never_spends_a_slot_on_the_container_first_frame() {
- let Some(mp4) = ffmpeg_gen_mp4(&[
- "-f",
- "lavfi",
- "-i",
- "testsrc=size=320x240:rate=10:duration=4",
- "-pix_fmt",
- "yuv420p",
- "-f",
- "mp4",
- ]) else {
- eprintln!("skipping: ffmpeg CLI not available");
- return;
- };
- let media_limits = limits();
- let metrics = TransformMetrics::default();
- let metadata = super::super::probe_av_metadata(
- &mp4,
- super::super::NSFW_PREVIEW_MAX_DIMENSION,
- &media_limits,
- None,
- )
- .expect("probe generated mp4");
- let frames = nsfw_video_scan_buffers(&NSFWScanSource {
- media_limits: &media_limits,
- metrics: &metrics,
- threshold: NSFWThreshold::new(0.85).expect("0.85 is a valid threshold"),
- content_type: "video/mp4",
- animated: false,
- frame_count: 0,
- input: &mp4,
- duration_seconds: metadata.probe.duration_seconds,
- deadline_ms: None,
- })
- .expect("video nsfw frames");
- assert_eq!(
- MAX_NSFW_SAMPLE_FRAMES,
- frames.len(),
- "every corroborating slot must hold a sampled frame"
- );
- for frame in &frames {
- assert_bounded_jpeg(frame, &media_limits);
- }
-}
-
-#[test]
-fn animated_gif_and_apng_frames_extract_through_the_native_decoders() {
- let media_limits = limits();
- let gif = animated_gif_fixture();
- let gif_pages = reconciled_frame_count(&gif, &media_limits);
- assert_eq!(2, gif_pages);
- let gif_frames = extract_native_animated_frames_for_nsfw(
- &media_limits,
- &gif,
- gif_pages,
- MediaType::GIF,
- None,
- )
- .expect("native gif nsfw frames");
- assert_eq!(2, gif_frames.len());
- for frame in &gif_frames {
- assert_bounded_jpeg(frame, &media_limits);
- }
-
- let apng = general_purpose::STANDARD
- .decode(APNG_FIXTURE_BASE64)
- .expect("apng fixture decodes");
- assert_eq!(
- 1,
- super::super::image_probe::probe_image_dims(&media_limits, &apng)
- .expect("apng dimensions")
- .pages,
- "this libvips build reports a single page for an APNG"
- );
- let apng_pages = reconciled_frame_count(&apng, &media_limits);
- assert_eq!(2, apng_pages);
- let apng_frames = extract_native_animated_frames_for_nsfw(
- &media_limits,
- &apng,
- apng_pages,
- MediaType::APNG,
- None,
- )
- .expect("native apng nsfw frames");
- assert_eq!(2, apng_frames.len());
- for frame in &apng_frames {
- assert_bounded_jpeg(frame, &media_limits);
- }
-}
-
-#[test]
-fn a_frame_count_that_disagrees_with_the_container_is_rejected() {
- let media_limits = limits();
- let gif = animated_gif_fixture();
- assert_eq!(
- Err(MediaError::MediaDecodeFailed),
- extract_native_animated_frames_for_nsfw(&media_limits, &gif, 3, MediaType::GIF, None)
- );
-}
-
-#[test]
-fn frame_indices_collapse_to_start_middle_and_end() {
- assert_eq!(
- Err(MediaError::InvalidImageDimensions),
- animated_nsfw_frame_indices(0)
- );
- assert_eq!(vec![0], animated_nsfw_frame_indices(1).unwrap());
- assert_eq!(vec![0, 1], animated_nsfw_frame_indices(2).unwrap());
- assert_eq!(vec![0, 1, 2], animated_nsfw_frame_indices(3).unwrap());
- assert_eq!(vec![0, 4, 8], animated_nsfw_frame_indices(9).unwrap());
-}
-
-#[test]
-fn a_sample_beyond_the_packet_budget_keeps_the_frames_that_decoded() {
- let Some(mp4) = ffmpeg_gen_mp4(&[
- "-f",
- "lavfi",
- "-i",
- "testsrc=size=64x64:rate=60:duration=12",
- "-pix_fmt",
- "yuv420p",
- "-g",
- "10000",
- "-f",
- "mp4",
- ]) else {
- eprintln!("skipping: ffmpeg CLI not available");
- return;
- };
- let media_limits = limits();
- let frames = extract_video_frames_for_nsfw(VideoNSFWFramesRequest {
- input: &mp4,
- duration_seconds: Some(12.0),
- deadline_ms: None,
- })
- .expect("a single keyframe video still scans on the samples that decoded");
- assert_eq!(MAX_NSFW_SAMPLE_FRAMES, frames.len());
- for frame in &frames {
- assert_bounded_jpeg(frame, &media_limits);
- }
-}
diff --git a/fluxer_media_proxy/src/media_process/tests/animated_apng.rs b/fluxer_media_proxy/src/media_process/tests/animated_apng.rs
deleted file mode 100644
index 6a2d8faa7..000000000
--- a/fluxer_media_proxy/src/media_process/tests/animated_apng.rs
+++ /dev/null
@@ -1,329 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use super::super::apng::{png_crc32, rewrite_actl_frame_count};
-use super::super::image_probe::probe_image_dims;
-use super::super::{
- AnimationLimits, AnimationMode, ImageDimensions, ImageOptions, ImageQuality, MediaError,
-};
-use super::fixtures::{
- animated_mode, parse_png_chunks, png_ihdr_dimensions, test_media_limits, transform_image,
-};
-use crate::{
- metrics::now_ms,
- output_format::OutputFormat,
- test_fixtures::{first_webp_anim_frame_size, gif_loop_count, webp_animation_loop_count},
-};
-use base64::Engine as _;
-
-#[test]
-fn animated_apng_input_transforms_through_ffmpeg_decode_path() {
- let fixture_b64 = "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAACXBIWXMAAAABAAAAAQBPJcTWAAAACGFjVEwAAAACAAAAAPONk3AAAAAaZmNUTAAAAAAAAAAQAAAAEAAAAAAAAAAAAAEABQAAaBqIGAAAAK1JREFUeJxjqGf4hxUxIKF/DH+BiOH/fxAiU4Mcgx0aYkBCtgy2QMRgZwdCg1yDCQMvEL1oMACix00mQCTFwANE/gx8QHSrUwuI0DXsbpkCVJ3IwBDEwADUsLprLkTD2ZoeoOp8OQZgaIEQxG5IiNqCXQARQw5pqJOooCFPj+Fcn96x9gxTBpS49NBk2DwlhBoaaOkHZUOGqYvDnrWJt6kRF6xADUAE1ABEuCIOAPEY5L3Pr8FWAAAAGmZjVEwAAAABAAAAAQAAAAEAAAAAAAAAAAABAAUAAMpQnTkAAAAQZmRBVAAAAAJ4nGOoZ/gHAAJ/AX511aUxAAAAAElFTkSuQmCC";
- let apng = base64::engine::general_purpose::STANDARD
- .decode(fixture_b64)
- .unwrap();
-
- let animated_webp = transform_image(
- &apng,
- &ImageOptions {
- width: Some(8),
- format: OutputFormat::WebP,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/webp", animated_webp.content_type);
- assert!(animated_webp.bytes.windows(4).any(|chunk| chunk == b"ANIM"));
- assert_eq!(
- Some((8, 8)),
- first_webp_anim_frame_size(&animated_webp.bytes)
- );
-
- let static_webp = transform_image(
- &apng,
- &ImageOptions {
- width: Some(8),
- format: OutputFormat::WebP,
- quality: ImageQuality::Lossless,
- animation: AnimationMode::Static,
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/webp", static_webp.content_type);
- assert!(!static_webp.bytes.windows(4).any(|chunk| chunk == b"ANIM"));
- assert_eq!(
- ImageDimensions {
- width: 8,
- height: 8,
- pages: 1,
- bands: 3,
- eight_bit: true,
- },
- probe_image_dims(&test_media_limits(), &static_webp.bytes).unwrap()
- );
-
- let animated_gif = transform_image(
- &apng,
- &ImageOptions {
- width: Some(8),
- format: OutputFormat::GIF,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/gif", animated_gif.content_type);
- assert!(animated_gif.bytes.starts_with(b"GIF89a") || animated_gif.bytes.starts_with(b"GIF87a"));
-
- let animated_png = transform_image(
- &apng,
- &ImageOptions {
- width: Some(8),
- format: OutputFormat::APNG,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/apng", animated_png.content_type);
- assert!(animated_png.bytes.starts_with(b"\x89PNG\r\n\x1a\n"));
- let apng_chunks = parse_png_chunks(&animated_png.bytes).unwrap();
- assert_eq!(Some((8, 8)), png_ihdr_dimensions(apng_chunks[0].data));
- assert!(apng_chunks.iter().any(|chunk| chunk.kind == *b"acTL"));
- assert!(apng_chunks.iter().any(|chunk| chunk.kind == *b"fcTL"));
- assert!(apng_chunks.iter().any(|chunk| chunk.kind == *b"fdAT"));
- assert_eq!(
- Some(2),
- apng_chunks
- .iter()
- .find(|chunk| chunk.kind == *b"acTL")
- .and_then(|chunk| chunk.data.get(..4))
- .map(|bytes| u32::from_be_bytes(bytes.try_into().unwrap()))
- );
-
- let animated_png_alias = transform_image(
- &apng,
- &ImageOptions {
- width: Some(8),
- format: OutputFormat::PNG,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/apng", animated_png_alias.content_type);
- let alias_chunks = parse_png_chunks(&animated_png_alias.bytes).unwrap();
- assert_eq!(Some((8, 8)), png_ihdr_dimensions(alias_chunks[0].data));
- assert!(alias_chunks.iter().any(|chunk| chunk.kind == *b"acTL"));
-}
-
-fn apng_num_plays(bytes: &[u8]) -> Option<u32> {
- parse_png_chunks(bytes)
- .ok()?
- .iter()
- .find(|chunk| chunk.kind == *b"acTL")
- .and_then(|chunk| chunk.data.get(4..8))
- .and_then(|plays| plays.try_into().ok())
- .map(u32::from_be_bytes)
-}
-
-fn patch_apng_num_plays(bytes: &[u8], num_plays: u32) -> Vec<u8> {
- let mut out = bytes.to_vec();
- let position = out
- .windows(4)
- .position(|window| window == b"acTL")
- .expect("fixture has an acTL chunk");
- let payload_start = position + 4;
- out[payload_start + 4..payload_start + 8].copy_from_slice(&num_plays.to_be_bytes());
- let payload: [u8; 8] = out[payload_start..payload_start + 8]
- .try_into()
- .expect("acTL payload is eight bytes");
- let crc = png_crc32(b"acTL", &payload, None).expect("crc without a deadline");
- out[payload_start + 8..payload_start + 12].copy_from_slice(&crc.to_be_bytes());
- out
-}
-
-#[test]
-fn animated_apng_transform_keeps_the_source_num_plays() {
- let fixture_b64 = "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAACXBIWXMAAAABAAAAAQBPJcTWAAAACGFjVEwAAAACAAAAAPONk3AAAAAaZmNUTAAAAAAAAAAQAAAAEAAAAAAAAAAAAAEABQAAaBqIGAAAAK1JREFUeJxjqGf4hxUxIKF/DH+BiOH/fxAiU4Mcgx0aYkBCtgy2QMRgZwdCg1yDCQMvEL1oMACix00mQCTFwANE/gx8QHSrUwuI0DXsbpkCVJ3IwBDEwADUsLprLkTD2ZoeoOp8OQZgaIEQxG5IiNqCXQARQw5pqJOooCFPj+Fcn96x9gxTBpS49NBk2DwlhBoaaOkHZUOGqYvDnrWJt6kRF6xADUAE1ABEuCIOAPEY5L3Pr8FWAAAAGmZjVEwAAAABAAAAAQAAAAEAAAAAAAAAAAABAAUAAMpQnTkAAAAQZmRBVAAAAAJ4nGOoZ/gHAAJ/AX511aUxAAAAAElFTkSuQmCC";
- let apng = base64::engine::general_purpose::STANDARD
- .decode(fixture_b64)
- .unwrap();
- assert_eq!(Some(0), apng_num_plays(&apng));
-
- let looped = patch_apng_num_plays(&apng, 7);
- assert_eq!(Some(7), apng_num_plays(&looped));
-
- let animated_png = transform_image(
- &looped,
- &ImageOptions {
- width: Some(8),
- format: OutputFormat::APNG,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/apng", animated_png.content_type);
- assert_eq!(Some(7), apng_num_plays(&animated_png.bytes));
-}
-
-#[test]
-fn animated_apng_encode_truncates_at_the_frame_cap_without_erroring() {
- let fixture_b64 = "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAACXBIWXMAAAABAAAAAQBPJcTWAAAACGFjVEwAAAACAAAAAPONk3AAAAAaZmNUTAAAAAAAAAAQAAAAEAAAAAAAAAAAAAEABQAAaBqIGAAAAK1JREFUeJxjqGf4hxUxIKF/DH+BiOH/fxAiU4Mcgx0aYkBCtgy2QMRgZwdCg1yDCQMvEL1oMACix00mQCTFwANE/gx8QHSrUwuI0DXsbpkCVJ3IwBDEwADUsLprLkTD2ZoeoOp8OQZgaIEQxG5IiNqCXQARQw5pqJOooCFPj+Fcn96x9gxTBpS49NBk2DwlhBoaaOkHZUOGqYvDnrWJt6kRF6xADUAE1ABEuCIOAPEY5L3Pr8FWAAAAGmZjVEwAAAABAAAAAQAAAAEAAAAAAAAAAAABAAUAAMpQnTkAAAAQZmRBVAAAAAJ4nGOoZ/gHAAJ/AX511aUxAAAAAElFTkSuQmCC";
- let apng = base64::engine::general_purpose::STANDARD
- .decode(fixture_b64)
- .unwrap();
-
- let capped = transform_image(
- &apng,
- &ImageOptions {
- width: Some(8),
- format: OutputFormat::APNG,
- quality: ImageQuality::Lossless,
- animation: AnimationMode::Animated(
- AnimationLimits::new(1, 30_000).expect("valid animation limits"),
- ),
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/apng", capped.content_type);
- let chunks = parse_png_chunks(&capped.bytes).unwrap();
- assert_eq!(
- Some(1),
- chunks
- .iter()
- .find(|chunk| chunk.kind == *b"acTL")
- .and_then(|chunk| chunk.data.get(..4))
- .and_then(|frames| frames.try_into().ok())
- .map(u32::from_be_bytes)
- );
- assert!(!chunks.iter().any(|chunk| chunk.kind == *b"fdAT"));
-}
-
-#[test]
-fn apng_with_saturated_num_plays_clamps_per_format_instead_of_failing() {
- let fixture_b64 = "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAACXBIWXMAAAABAAAAAQBPJcTWAAAACGFjVEwAAAACAAAAAPONk3AAAAAaZmNUTAAAAAAAAAAQAAAAEAAAAAAAAAAAAAEABQAAaBqIGAAAAK1JREFUeJxjqGf4hxUxIKF/DH+BiOH/fxAiU4Mcgx0aYkBCtgy2QMRgZwdCg1yDCQMvEL1oMACix00mQCTFwANE/gx8QHSrUwuI0DXsbpkCVJ3IwBDEwADUsLprLkTD2ZoeoOp8OQZgaIEQxG5IiNqCXQARQw5pqJOooCFPj+Fcn96x9gxTBpS49NBk2DwlhBoaaOkHZUOGqYvDnrWJt6kRF6xADUAE1ABEuCIOAPEY5L3Pr8FWAAAAGmZjVEwAAAABAAAAAQAAAAEAAAAAAAAAAAABAAUAAMpQnTkAAAAQZmRBVAAAAAJ4nGOoZ/gHAAJ/AX511aUxAAAAAElFTkSuQmCC";
- let apng = base64::engine::general_purpose::STANDARD
- .decode(fixture_b64)
- .unwrap();
- let saturated = patch_apng_num_plays(&apng, u32::MAX);
- assert_eq!(Some(u32::MAX), apng_num_plays(&saturated));
-
- let animated_webp = transform_image(
- &saturated,
- &ImageOptions {
- width: Some(8),
- format: OutputFormat::WebP,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/webp", animated_webp.content_type);
- assert_eq!(
- Some(u16::MAX),
- webp_animation_loop_count(&animated_webp.bytes)
- );
-
- let animated_gif = transform_image(
- &saturated,
- &ImageOptions {
- width: Some(8),
- format: OutputFormat::GIF,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/gif", animated_gif.content_type);
- assert_eq!(Some(u16::MAX), gif_loop_count(&animated_gif.bytes));
-
- let animated_png = transform_image(
- &saturated,
- &ImageOptions {
- width: Some(8),
- format: OutputFormat::APNG,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/apng", animated_png.content_type);
- assert_eq!(Some(u32::MAX), apng_num_plays(&animated_png.bytes));
-}
-
-#[test]
-fn animated_apng_encode_stops_at_the_deadline_instead_of_timing_out() {
- let fixture_b64 = "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAACXBIWXMAAAABAAAAAQBPJcTWAAAACGFjVEwAAAACAAAAAPONk3AAAAAaZmNUTAAAAAAAAAAQAAAAEAAAAAAAAAAAAAEABQAAaBqIGAAAAK1JREFUeJxjqGf4hxUxIKF/DH+BiOH/fxAiU4Mcgx0aYkBCtgy2QMRgZwdCg1yDCQMvEL1oMACix00mQCTFwANE/gx8QHSrUwuI0DXsbpkCVJ3IwBDEwADUsLprLkTD2ZoeoOp8OQZgaIEQxG5IiNqCXQARQw5pqJOooCFPj+Fcn96x9gxTBpS49NBk2DwlhBoaaOkHZUOGqYvDnrWJt6kRF6xADUAE1ABEuCIOAPEY5L3Pr8FWAAAAGmZjVEwAAAABAAAAAQAAAAEAAAAAAAAAAAABAAUAAMpQnTkAAAAQZmRBVAAAAAJ4nGOoZ/gHAAJ/AX511aUxAAAAAElFTkSuQmCC";
- let apng = base64::engine::general_purpose::STANDARD
- .decode(fixture_b64)
- .unwrap();
- let options = |deadline_ms: Option<i64>| ImageOptions {
- width: Some(8),
- format: OutputFormat::APNG,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- deadline_ms,
- ..Default::default()
- };
- assert_eq!(
- "image/apng",
- transform_image(&apng, &options(None)).unwrap().content_type
- );
-
- let expired_encode_deadline = now_ms() + 2_000;
- assert!(matches!(
- transform_image(&apng, &options(Some(expired_encode_deadline))),
- Err(MediaError::MediaEncodeFailed)
- ));
-}
-
-#[test]
-fn rewriting_the_actl_frame_count_keeps_the_chunk_crc_valid() {
- let mut encoded = vec![0u8; 33];
- let actl_offset = encoded.len();
- let mut payload = [0u8; 8];
- payload[..4].copy_from_slice(&7u32.to_be_bytes());
- payload[4..].copy_from_slice(&3u32.to_be_bytes());
- encoded.extend_from_slice(&8u32.to_be_bytes());
- encoded.extend_from_slice(b"acTL");
- encoded.extend_from_slice(&payload);
- encoded.extend_from_slice(
- &png_crc32(b"acTL", &payload, None)
- .expect("crc without a deadline")
- .to_be_bytes(),
- );
-
- rewrite_actl_frame_count(&mut encoded, actl_offset, 2, None)
- .expect("acTL frame count is rewritten");
-
- let payload_start = actl_offset + 8;
- let payload_end = payload_start + 8;
- assert_eq!(
- 2,
- u32::from_be_bytes(
- encoded[payload_start..payload_start + 4]
- .try_into()
- .unwrap()
- )
- );
- assert_eq!(
- 3,
- u32::from_be_bytes(encoded[payload_start + 4..payload_end].try_into().unwrap())
- );
- assert_eq!(
- png_crc32(b"acTL", &encoded[payload_start..payload_end], None).unwrap(),
- u32::from_be_bytes(encoded[payload_end..payload_end + 4].try_into().unwrap())
- );
-}
diff --git a/fluxer_media_proxy/src/media_process/tests/animated_gif.rs b/fluxer_media_proxy/src/media_process/tests/animated_gif.rs
deleted file mode 100644
index ccc53b30d..000000000
--- a/fluxer_media_proxy/src/media_process/tests/animated_gif.rs
+++ /dev/null
@@ -1,460 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use super::super::animated_transform::{GifResizeDims, gif_resize_dims};
-use super::super::{
- AnimationLimits, AnimationMode, ImageOptions, ImageQuality, MediaError, ResizeMode,
-};
-use super::fixtures::{animated_mode, parse_png_chunks, png_ihdr_dimensions, transform_image};
-use crate::{
- mime,
- output_format::OutputFormat,
- test_fixtures::{
- animated_gif_fixture, animated_gif_frames, first_webp_anim_frame_size, gif_frame_delays_cs,
- gif_loop_count, webp_canvas_size,
- },
-};
-
-#[test]
-fn animated_gif_encodes_to_animated_webp_with_alpha() {
- let gif = animated_gif_fixture();
-
- let animated_webp = transform_image(
- &gif,
- &ImageOptions {
- width: Some(32),
- height: Some(32),
- format: OutputFormat::WebP,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/webp", animated_webp.content_type);
- assert!(animated_webp.bytes.starts_with(b"RIFF"));
- assert_eq!(&animated_webp.bytes[8..12], b"WEBP");
- assert!(animated_webp.bytes.windows(4).any(|chunk| chunk == b"ANIM"));
- assert!(
- animated_webp.bytes.windows(4).any(|chunk| chunk == b"ALPH")
- || animated_webp.bytes.windows(4).any(|chunk| chunk == b"VP8L")
- );
- let (canvas_width, canvas_height, feature_flags) =
- webp_canvas_size(&animated_webp.bytes).unwrap();
- assert_eq!((32, 32), (canvas_width, canvas_height));
- assert_ne!(0, feature_flags & 0x02);
- assert_ne!(0, feature_flags & 0x10);
- assert_eq!(
- Some((32, 32)),
- first_webp_anim_frame_size(&animated_webp.bytes)
- );
-
- let static_webp = transform_image(
- &gif,
- &ImageOptions {
- width: Some(32),
- height: Some(32),
- format: OutputFormat::WebP,
- quality: ImageQuality::Lossless,
- animation: AnimationMode::Static,
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/webp", static_webp.content_type);
- assert!(static_webp.bytes.starts_with(b"RIFF"));
- assert_eq!(&static_webp.bytes[8..12], b"WEBP");
-
- let animated_gif = transform_image(
- &gif,
- &ImageOptions {
- width: Some(32),
- height: Some(32),
- format: OutputFormat::GIF,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/gif", animated_gif.content_type);
- assert!(animated_gif.bytes.starts_with(b"GIF89a") || animated_gif.bytes.starts_with(b"GIF87a"));
-
- let animated_png = transform_image(
- &gif,
- &ImageOptions {
- width: Some(32),
- height: Some(32),
- format: OutputFormat::APNG,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/apng", animated_png.content_type);
- let apng_chunks = parse_png_chunks(&animated_png.bytes).unwrap();
- assert_eq!(Some((32, 32)), png_ihdr_dimensions(apng_chunks[0].data));
- assert!(apng_chunks.iter().any(|chunk| chunk.kind == *b"acTL"));
- assert!(apng_chunks.iter().any(|chunk| chunk.kind == *b"fcTL"));
- assert!(apng_chunks.iter().any(|chunk| chunk.kind == *b"fdAT"));
-}
-
-#[test]
-fn animated_gif_resize_preserves_last_frame_delay() {
- let gif = animated_gif_fixture();
- assert_eq!(vec![20, 20], gif_frame_delays_cs(&gif));
-
- let resized = transform_image(
- &gif,
- &ImageOptions {
- width: Some(16),
- height: Some(16),
- format: OutputFormat::GIF,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap();
-
- assert_eq!("image/gif", resized.content_type);
- assert_eq!(vec![20, 20], gif_frame_delays_cs(&resized.bytes));
-}
-
-#[test]
-fn animated_gif_without_a_resize_passes_through_byte_identically() {
- let gif = animated_gif_fixture();
- let passed_through = transform_image(
- &gif,
- &ImageOptions {
- format: OutputFormat::GIF,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap();
-
- assert_eq!("image/gif", passed_through.content_type);
- assert_eq!(gif, passed_through.bytes);
-}
-
-#[test]
-fn animated_gif_with_trailing_bytes_after_the_trailer_passes_through_byte_identically() {
- let mut gif = animated_gif_frames(3, 20);
- gif.extend_from_slice(b"trailing garbage");
- let passed_through = transform_image(
- &gif,
- &ImageOptions {
- format: OutputFormat::GIF,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .expect("a gif with trailing bytes after the trailer still passes through");
-
- assert_eq!("image/gif", passed_through.content_type);
- assert_eq!(gif, passed_through.bytes);
-}
-
-#[test]
-fn animated_gif_with_trailing_bytes_after_the_trailer_resizes() {
- for tail in [&[0u8; 4096][..], b"trailing garbage"] {
- let mut gif = animated_gif_frames(3, 20);
- gif.extend_from_slice(tail);
- let resized = transform_image(
- &gif,
- &ImageOptions {
- width: Some(8),
- format: OutputFormat::GIF,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .expect("a gif with trailing bytes after the trailer still resizes");
-
- assert_animated_gif(&resized.bytes, 3);
- assert_eq!(vec![20u16; 3], gif_frame_delays_cs(&resized.bytes));
- }
-}
-
-#[test]
-fn animated_gif_over_the_frame_cap_passes_through_byte_identically() {
- let gif = animated_gif_frames(5, 20);
- let passed_through = transform_image(
- &gif,
- &ImageOptions {
- format: OutputFormat::GIF,
- animation: AnimationMode::Animated(
- AnimationLimits::new(3, 30_000).expect("valid animation limits"),
- ),
- ..Default::default()
- },
- )
- .expect("a gif over the frame cap still passes through");
-
- assert_eq!("image/gif", passed_through.content_type);
- assert_eq!(gif, passed_through.bytes);
-}
-
-#[test]
-fn animated_gif_over_the_duration_cap_passes_through_byte_identically() {
- let gif = animated_gif_frames(5, 20);
- let passed_through = transform_image(
- &gif,
- &ImageOptions {
- format: OutputFormat::GIF,
- animation: AnimationMode::Animated(
- AnimationLimits::new(4_096, 400).expect("valid animation limits"),
- ),
- ..Default::default()
- },
- )
- .expect("a gif over the duration cap still passes through");
-
- assert_eq!("image/gif", passed_through.content_type);
- assert_eq!(gif, passed_through.bytes);
-}
-
-fn resized_animated_gif_with_encode_limits(
- input: &[u8],
- max_frames: u32,
- max_duration_ms: u32,
-) -> Vec<u8> {
- transform_image(
- input,
- &ImageOptions {
- width: Some(8),
- format: OutputFormat::GIF,
- quality: ImageQuality::Lossless,
- animation: AnimationMode::Animated(
- AnimationLimits::new(max_frames, max_duration_ms).expect("valid animation limits"),
- ),
- ..Default::default()
- },
- )
- .expect("animated gif resize ignores the encode caps")
- .bytes
-}
-
-fn assert_animated_gif(bytes: &[u8], frames: usize) {
- assert_eq!(b"GIF89a", &bytes[..6]);
- assert_eq!(Some(&0x3b), bytes.last());
- assert_eq!(frames, gif_frame_delays_cs(bytes).len());
-}
-
-#[test]
-fn animated_gif_resize_keeps_every_frame_past_the_encode_caps() {
- // A resize is not a re-time. The old proxy handed the ffmpeg resizer only the decode caps, so
- // a long GIF came back whole; binding the encode budget here cut the tail off anything past
- // FLUXER_MEDIA_PROXY_MAX_ENCODE_DURATION_MS while the same GIF passed through untouched when
- // no resize was asked for.
- let gif = animated_gif_frames(5, 20);
- assert_eq!(vec![20u16; 5], gif_frame_delays_cs(&gif));
-
- let uncapped = resized_animated_gif_with_encode_limits(&gif, 4_096, 30_000);
- assert_animated_gif(&uncapped, 5);
- assert_eq!(vec![20u16; 5], gif_frame_delays_cs(&uncapped));
-
- for (max_frames, max_duration_ms) in [(3, 30_000), (1, 30_000), (4_096, 400), (1, 1)] {
- let capped = resized_animated_gif_with_encode_limits(&gif, max_frames, max_duration_ms);
- assert_animated_gif(&capped, 5);
- assert_eq!(uncapped, capped);
- }
-}
-
-fn cover_cropped_animated_gif_with_encode_limits(
- input: &[u8],
- max_frames: u32,
- max_duration_ms: u32,
-) -> Vec<u8> {
- transform_image(
- input,
- &ImageOptions {
- width: Some(8),
- height: Some(8),
- format: OutputFormat::GIF,
- quality: ImageQuality::Lossless,
- resize_mode: ResizeMode::Cover,
- animation: AnimationMode::Animated(
- AnimationLimits::new(max_frames, max_duration_ms).expect("valid animation limits"),
- ),
- ..Default::default()
- },
- )
- .expect("the generic animated encode writes every frame without failing")
- .bytes
-}
-
-#[test]
-fn generic_animated_gif_encode_output_is_unchanged_by_the_encode_caps() {
- let gif = animated_gif_frames(5, 20);
- assert_eq!(vec![20u16; 5], gif_frame_delays_cs(&gif));
-
- let uncapped = cover_cropped_animated_gif_with_encode_limits(&gif, 4_096, 30_000);
- assert_animated_gif(&uncapped, 5);
- assert_eq!(
- uncapped,
- cover_cropped_animated_gif_with_encode_limits(&gif, 2, 30_000)
- );
- assert_eq!(
- uncapped,
- cover_cropped_animated_gif_with_encode_limits(&gif, 4_096, 400)
- );
-}
-
-#[test]
-fn vips_gif_encode_writes_every_source_frame_past_the_encode_caps() {
- let gif = animated_gif_frames(5, 20);
- assert_eq!(vec![20u16; 5], gif_frame_delays_cs(&gif));
-
- for (max_frames, max_duration_ms) in [(4_096, 30_000), (2, 30_000), (4_096, 400), (1, 1)] {
- assert_animated_gif(
- &cover_cropped_animated_gif_with_encode_limits(&gif, max_frames, max_duration_ms),
- 5,
- );
- }
-}
-
-#[test]
-fn a_zero_delay_source_resizes_to_the_hundred_millisecond_browser_default() {
- // A GIF that declares a 0 cs delay is not a 20 ms animation: authoring tools emit 0 and
- // every renderer shows it at 100 ms. Clamping it to the fast-frame minimum instead played
- // the resized animation five times faster than the original.
- let gif = animated_gif_frames(5, 0);
- assert_eq!(vec![0u16; 5], gif_frame_delays_cs(&gif));
-
- let resized = transform_image(
- &gif,
- &ImageOptions {
- width: Some(8),
- format: OutputFormat::GIF,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!(vec![10u16; 5], gif_frame_delays_cs(&resized.bytes));
-}
-
-#[test]
-fn a_sub_minimum_nonzero_delay_still_clamps_to_the_fast_frame_minimum() {
- // A declared-but-tiny delay keeps the 20 ms floor; only "no delay at all" means 100 ms.
- let gif = animated_gif_frames(5, 1);
- let resized = transform_image(
- &gif,
- &ImageOptions {
- width: Some(8),
- format: OutputFormat::GIF,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!(vec![2u16; 5], gif_frame_delays_cs(&resized.bytes));
-}
-
-#[test]
-fn animated_gif_resize_still_errors_on_an_expired_deadline() {
- let gif = animated_gif_frames(5, 20);
- assert!(matches!(
- transform_image(
- &gif,
- &ImageOptions {
- width: Some(8),
- format: OutputFormat::GIF,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- deadline_ms: Some(1),
- ..Default::default()
- },
- ),
- Err(MediaError::RequestTimeout)
- ));
-}
-
-#[test]
-fn animated_gif_resize_preserves_the_source_loop_count() {
- let gif = animated_gif_fixture();
- assert_eq!(Some(0), gif_loop_count(&gif));
-
- let resized = transform_image(
- &gif,
- &ImageOptions {
- width: Some(16),
- height: Some(16),
- format: OutputFormat::GIF,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap();
-
- assert_eq!("image/gif", resized.content_type);
- assert_eq!(gif_loop_count(&gif), gif_loop_count(&resized.bytes));
-}
-
-#[test]
-fn animated_gif_two_bounds_fit_inside_without_distortion() {
- let dims = gif_resize_dims(
- mime::SniffInfo {
- mime: "image/gif",
- animated: true,
- width: 320,
- height: 240,
- ..Default::default()
- },
- &ImageOptions {
- width: Some(240),
- height: Some(240),
- format: OutputFormat::GIF,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .expect("4:3 GIF should be reduced to fit in a 240px square");
-
- assert_eq!(240, dims.width);
- assert_eq!(180, dims.height);
-}
-
-#[test]
-fn the_gif_resize_work_budget_counts_output_pixels_across_every_frame() {
- let thumbnail = GifResizeDims {
- width: 480,
- height: 270,
- };
- assert!(thumbnail.fits_work_budget(129));
- assert!(!thumbnail.fits_work_budget(130));
- assert!(!thumbnail.fits_work_budget(739));
- let still = GifResizeDims {
- width: 4096,
- height: 4096,
- };
- assert!(still.fits_work_budget(1));
- assert!(still.fits_work_budget(0));
- assert!(!still.fits_work_budget(2));
-}
-
-#[test]
-fn an_animated_gif_resize_over_the_work_budget_passes_through_byte_identically() {
- let mut gif = animated_gif_frames(2, 20);
- gif[6..8].copy_from_slice(&4096u16.to_le_bytes());
- gif[8..10].copy_from_slice(&4096u16.to_le_bytes());
- let passed_through = transform_image(
- &gif,
- &ImageOptions {
- width: Some(4095),
- format: OutputFormat::GIF,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .expect("a gif too costly to resize still passes through");
-
- assert_eq!("image/gif", passed_through.content_type);
- assert_eq!(gif, passed_through.bytes);
-}
diff --git a/fluxer_media_proxy/src/media_process/tests/animated_webp.rs b/fluxer_media_proxy/src/media_process/tests/animated_webp.rs
deleted file mode 100644
index cce8022cd..000000000
--- a/fluxer_media_proxy/src/media_process/tests/animated_webp.rs
+++ /dev/null
@@ -1,305 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use super::super::encoding::try_transform_animated_webp_direct;
-use super::super::image_probe::probe_image_dims;
-use super::super::native_runtime::ensure_vips_init;
-use super::super::{
- AnimationLimits, AnimationMode, ImageOptions, ImageQuality, MediaError, ResolvedImageQuality,
-};
-use super::fixtures::{animated_mode, assert_animated_webp, test_media_limits, transform_image};
-use crate::{
- mime,
- native::{self, NativeStatus},
- output_format::OutputFormat,
- test_fixtures::{
- animated_gif_fixture, animated_gif_frames, gif_frame_delays_cs, gif_loop_count,
- webp_animation_loop_count, webp_canvas_size, webp_chunk_payloads, webp_with_metadata_chunk,
- },
-};
-use libc::c_int;
-
-fn webp_direct_transform(input: &[u8]) -> Option<Vec<u8>> {
- ensure_vips_init().expect("libvips initialises");
- try_transform_animated_webp_direct(
- input,
- &ImageOptions {
- width: Some(16),
- format: OutputFormat::WebP,
- animation: animated_mode(),
- ..Default::default()
- },
- ResolvedImageQuality::High,
- None,
- &test_media_limits(),
- )
- .expect("direct animated webp transform succeeds or falls through")
-}
-
-fn animated_webp_source() -> Vec<u8> {
- transform_image(
- &animated_gif_fixture(),
- &ImageOptions {
- width: Some(32),
- height: Some(32),
- format: OutputFormat::WebP,
- quality: ImageQuality::Lossless,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .expect("animated gif encodes to animated webp")
- .bytes
-}
-
-#[test]
-fn animated_webp_transforms_directly_and_falls_through_on_embedded_metadata() {
- let source = animated_webp_source();
- assert!(mime::sniff(&source).animated);
-
- let direct = transform_image(
- &source,
- &ImageOptions {
- width: Some(16),
- format: OutputFormat::WebP,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .expect("animated webp transforms through the direct path");
- assert_eq!("image/webp", direct.content_type);
- assert!(direct.bytes.starts_with(b"RIFF"));
- assert_eq!(&direct.bytes[8..12], b"WEBP");
- assert!(direct.bytes.windows(4).any(|chunk| chunk == b"ANIM"));
- let (canvas_width, canvas_height, feature_flags) =
- webp_canvas_size(&direct.bytes).expect("direct output has a VP8X canvas");
- assert_eq!((16, 16), (canvas_width, canvas_height));
- assert_ne!(0, feature_flags & 0x02);
- let source_frames = webp_chunk_payloads(&source, b"ANMF").len();
- assert!(source_frames > 1);
- assert_eq!(
- source_frames,
- webp_chunk_payloads(&direct.bytes, b"ANMF").len()
- );
-
- for (fourcc, flag) in [(b"ICCP", 0x20u8), (b"EXIF", 0x08), (b"XMP ", 0x04)] {
- let tagged = webp_with_metadata_chunk(&source, fourcc, flag)
- .expect("animated webp accepts an embedded metadata chunk");
- assert_eq!(
- None,
- webp_direct_transform(&tagged),
- "chunk {}",
- String::from_utf8_lossy(fourcc)
- );
- let fallback = transform_image(
- &tagged,
- &ImageOptions {
- width: Some(16),
- format: OutputFormat::WebP,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .expect("tagged animated webp falls through to the generic path");
- assert_eq!("image/webp", fallback.content_type);
- assert!(fallback.bytes.windows(4).any(|chunk| chunk == b"ANIM"));
- }
- assert!(
- webp_direct_transform(&source).is_some(),
- "untagged source stays on the direct path"
- );
-}
-
-#[test]
-fn animated_webp_encode_keeps_the_source_loop_count() {
- let mut gif = animated_gif_fixture();
- let netscape = gif
- .windows(11)
- .position(|window| window == b"NETSCAPE2.0")
- .expect("fixture has a NETSCAPE application extension");
- gif[netscape + 13] = 3;
- gif[netscape + 14] = 0;
- assert_eq!(Some(3), gif_loop_count(&gif));
-
- let out = transform_image(
- &gif,
- &ImageOptions {
- width: Some(16),
- format: OutputFormat::WebP,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!(Some(4), webp_animation_loop_count(&out.bytes));
-}
-
-#[test]
-fn animated_webp_nsfw_frames_extract_as_bounded_jpegs() {
- let source = animated_webp_source();
- let indices: [c_int; 2] = [0, 1];
- let mut frames = native::nsfw_frame_output::NSFWFrameOutput::new(indices.len());
- let status = NativeStatus::from_code(unsafe {
- native::fluxer_webp_extract_frames_for_nsfw(
- source.as_ptr().cast(),
- source.len(),
- 0,
- 0,
- indices.as_ptr(),
- indices.len(),
- 16,
- test_media_limits().animated_total_pixels(),
- 1_048_576,
- frames.as_mut_ptr(),
- )
- });
- assert_eq!(NativeStatus::Ok, status);
- let extracted = frames.copy_frames().expect("frames copy out");
- assert_eq!(2, extracted.len());
- for frame in &extracted {
- assert_eq!(&[0xFF, 0xD8], &frame[..2]);
- let dims = probe_image_dims(&test_media_limits(), frame).unwrap();
- assert!(dims.width <= 512 && dims.height <= 512);
- }
-}
-
-#[test]
-fn zero_delay_animation_frames_are_clamped_instead_of_rejected() {
- let mut gif = animated_gif_fixture();
- let mut offset = 0usize;
- let mut patched = 0usize;
- while offset + 8 <= gif.len() {
- if gif[offset] == 0x21 && gif[offset + 1] == 0xF9 && gif[offset + 2] == 0x04 {
- gif[offset + 4] = 0;
- gif[offset + 5] = 0;
- patched += 1;
- }
- offset += 1;
- }
- assert_eq!(2, patched);
- assert!(gif_frame_delays_cs(&gif).iter().all(|delay| *delay == 0));
-
- for format in [OutputFormat::WebP, OutputFormat::APNG] {
- let out = transform_image(
- &gif,
- &ImageOptions {
- width: Some(16),
- format,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .unwrap_or_else(|err| panic!("zero-delay {format:?} encode failed: {err:?}"));
- assert_eq!(format.mime(), out.content_type);
- }
-}
-
-fn animated_webp_with_encode_limits(
- input: &[u8],
- max_frames: u32,
- max_duration_ms: u32,
-) -> Vec<u8> {
- transform_image(
- input,
- &ImageOptions {
- width: Some(16),
- format: OutputFormat::WebP,
- animation: AnimationMode::Animated(
- AnimationLimits::new(max_frames, max_duration_ms).expect("valid animation limits"),
- ),
- ..Default::default()
- },
- )
- .expect("animated webp encode truncates instead of failing")
- .bytes
-}
-
-fn direct_animated_webp_with_encode_limits(
- input: &[u8],
- max_frames: u32,
- max_duration_ms: u32,
-) -> Vec<u8> {
- ensure_vips_init().expect("libvips initialises");
- try_transform_animated_webp_direct(
- input,
- &ImageOptions {
- width: Some(16),
- format: OutputFormat::WebP,
- animation: AnimationMode::Animated(
- AnimationLimits::new(max_frames, max_duration_ms).expect("valid animation limits"),
- ),
- ..Default::default()
- },
- ResolvedImageQuality::High,
- None,
- &test_media_limits(),
- )
- .expect("direct animated webp transform truncates instead of failing")
- .expect("direct animated webp transform stays on the direct path")
-}
-
-#[test]
-fn animated_webp_encode_truncates_at_the_frame_cap_without_erroring() {
- let gif = animated_gif_frames(4, 20);
- assert_eq!(vec![20u16; 4], gif_frame_delays_cs(&gif));
-
- assert_animated_webp(&animated_webp_with_encode_limits(&gif, 4_096, 30_000), 4);
- assert_animated_webp(&animated_webp_with_encode_limits(&gif, 3, 30_000), 3);
- assert_animated_webp(&animated_webp_with_encode_limits(&gif, 2, 30_000), 2);
-}
-
-#[test]
-fn animated_webp_encode_truncates_at_the_duration_cap_without_erroring() {
- let gif = animated_gif_frames(4, 20);
-
- assert_animated_webp(&animated_webp_with_encode_limits(&gif, 4_096, 800), 4);
- assert_animated_webp(&animated_webp_with_encode_limits(&gif, 4_096, 600), 3);
- assert_animated_webp(&animated_webp_with_encode_limits(&gif, 4_096, 400), 2);
-}
-
-#[test]
-fn animated_webp_direct_transform_truncates_at_the_encode_caps() {
- let source = animated_webp_with_encode_limits(&animated_gif_frames(4, 20), 4_096, 30_000);
- assert_animated_webp(&source, 4);
-
- assert_animated_webp(
- &direct_animated_webp_with_encode_limits(&source, 4_096, 30_000),
- 4,
- );
- assert_animated_webp(
- &direct_animated_webp_with_encode_limits(&source, 2, 30_000),
- 2,
- );
- assert_animated_webp(
- &direct_animated_webp_with_encode_limits(&source, 4_096, 400),
- 2,
- );
-}
-
-#[test]
-fn animated_webp_encode_still_errors_on_an_expired_deadline() {
- let expired = ImageOptions {
- width: Some(16),
- format: OutputFormat::WebP,
- animation: animated_mode(),
- deadline_ms: Some(1),
- ..Default::default()
- };
- let gif = animated_gif_frames(4, 20);
- assert!(matches!(
- transform_image(&gif, &expired),
- Err(MediaError::RequestTimeout)
- ));
-
- let source = animated_webp_with_encode_limits(&gif, 4_096, 30_000);
- ensure_vips_init().expect("libvips initialises");
- assert!(matches!(
- try_transform_animated_webp_direct(
- &source,
- &expired,
- ResolvedImageQuality::High,
- None,
- &test_media_limits(),
- ),
- Err(MediaError::RequestTimeout)
- ));
-}
diff --git a/fluxer_media_proxy/src/media_process/tests/encoding.rs b/fluxer_media_proxy/src/media_process/tests/encoding.rs
deleted file mode 100644
index 2928db195..000000000
--- a/fluxer_media_proxy/src/media_process/tests/encoding.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use super::super::encoding::anim_limits_from_options;
-use super::super::transform_plan::{AutoQualitySource, output_suffix, resolve_auto_quality};
-use super::super::{AnimatedProbe, EncodeEffort, ImageOptions, ImageQuality, ResolvedImageQuality};
-use super::fixtures::effort;
-use crate::{mime, output_format::OutputFormat};
-
-#[test]
-fn png_compression_drops_for_outputs_above_a_megapixel() {
- let png_suffix = |output_pixels| {
- output_suffix(
- OutputFormat::PNG,
- ResolvedImageQuality::High,
- None,
- None,
- output_pixels,
- )
- .expect("png output suffix")
- .into_string()
- .expect("utf8 output suffix")
- };
- assert_eq!(
- ".png[strip,compression=9,filter=all]",
- png_suffix(160 * 160)
- );
- assert_eq!(
- ".png[strip,compression=9,filter=all]",
- png_suffix(1024 * 1024)
- );
- assert_eq!(
- ".png[strip,compression=6,filter=all]",
- png_suffix(1024 * 1024 + 1)
- );
- assert_eq!(
- ".png[strip,compression=6,filter=all]",
- png_suffix(3024 * 4032)
- );
-}
-
-#[test]
-fn auto_animated_palette_quality_matches_v1_thresholds() {
- let gif_header = b"GIF89a\x01\x00\x01\x00";
- let small_probe = AnimatedProbe {
- width: 300,
- height: 225,
- pages: 100,
- };
- let large_probe = AnimatedProbe {
- width: 480,
- height: 480,
- pages: 240,
- };
- let resolved = |quality, probe, requested| {
- resolve_auto_quality(
- AutoQualitySource {
- format: OutputFormat::WebP,
- animated: true,
- sniffed_mime: mime::sniff(gif_header).mime,
- input: gif_header,
- quality,
- probe: Some(probe),
- },
- requested,
- )
- };
-
- assert_eq!(
- ResolvedImageQuality::Lossless,
- resolved(ImageQuality::Auto, small_probe, None).quality
- );
- assert_eq!(
- ResolvedImageQuality::High,
- resolved(ImageQuality::Auto, large_probe, None).quality
- );
- assert_eq!(
- ResolvedImageQuality::High,
- resolved(ImageQuality::High, small_probe, None).quality
- );
- assert_eq!(
- ResolvedImageQuality::Low,
- resolved(ImageQuality::Low, small_probe, None).quality
- );
- assert_eq!(
- None,
- resolved(ImageQuality::Auto, small_probe, None).effort_override
- );
- assert_eq!(
- Some(EncodeEffort::minimum()),
- resolved(ImageQuality::Auto, large_probe, None).effort_override
- );
- assert_eq!(
- Some(effort(2)),
- resolved(ImageQuality::Auto, large_probe, Some(effort(2))).effort_override
- );
-}
-
-#[test]
-fn animated_encode_deadline_keeps_flush_headroom() {
- assert_eq!(
- Some(17_000),
- anim_limits_from_options(&ImageOptions {
- deadline_ms: Some(20_000),
- ..Default::default()
- })
- .deadline_unix_ms
- );
- assert_eq!(
- Some(1_500),
- anim_limits_from_options(&ImageOptions {
- deadline_ms: Some(1_500),
- ..Default::default()
- })
- .deadline_unix_ms
- );
- assert_eq!(
- None,
- anim_limits_from_options(&ImageOptions::default()).deadline_unix_ms
- );
- assert_eq!(
- Some(20_000),
- anim_limits_from_options(&ImageOptions {
- deadline_ms: Some(20_000),
- ..Default::default()
- })
- .flush_deadline_unix_ms
- );
-}
diff --git a/fluxer_media_proxy/src/media_process/tests/fixtures.rs b/fluxer_media_proxy/src/media_process/tests/fixtures.rs
deleted file mode 100644
index cc5904909..000000000
--- a/fluxer_media_proxy/src/media_process/tests/fixtures.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use super::super::native_runtime::ensure_vips_init;
-use super::super::{
- AnimationLimits, AnimationMode, EncodeEffort, ImageOptions, MediaError, MediaLimits,
- MetadataOptions, PNG_SIGNATURE, ProcessedMedia, finish_metadata, prepare_metadata,
-};
-use crate::{
- constants,
- metrics::transform::TransformMetrics,
- native::{self, NativeStatus, VipsImageHandle, buffer::NativeBuffer},
- nsfw::NSFWClient,
- test_fixtures::webp_chunk_payloads,
-};
-use libc::{c_void, size_t};
-use std::{ffi::CString, ptr};
-
-#[derive(Clone, Copy, Debug)]
-pub(super) struct PngChunk<'a> {
- pub(super) kind: [u8; 4],
- pub(super) data: &'a [u8],
-}
-
-pub(super) fn parse_png_chunks(bytes: &[u8]) -> Result<Vec<PngChunk<'_>>, MediaError> {
- if bytes.len() < PNG_SIGNATURE.len() || &bytes[..PNG_SIGNATURE.len()] != PNG_SIGNATURE {
- return Err(MediaError::MediaEncodeFailed);
- }
- let mut chunks = Vec::new();
- let mut offset = PNG_SIGNATURE.len();
- while offset + 12 <= bytes.len() {
- let len = u32::from_be_bytes([
- bytes[offset],
- bytes[offset + 1],
- bytes[offset + 2],
- bytes[offset + 3],
- ]) as usize;
- let kind: [u8; 4] = bytes[offset + 4..offset + 8]
- .try_into()
- .map_err(|_| MediaError::MediaEncodeFailed)?;
- let data_start = offset + 8;
- let data_end = data_start
- .checked_add(len)
- .ok_or(MediaError::MediaEncodeFailed)?;
- let crc_end = data_end
- .checked_add(4)
- .ok_or(MediaError::MediaEncodeFailed)?;
- if crc_end > bytes.len() {
- return Err(MediaError::MediaEncodeFailed);
- }
- chunks.push(PngChunk {
- kind,
- data: &bytes[data_start..data_end],
- });
- offset = crc_end;
- if kind == *b"IEND" {
- return Ok(chunks);
- }
- }
- Err(MediaError::MediaEncodeFailed)
-}
-
-pub(super) fn png_ihdr_dimensions(ihdr: &[u8]) -> Option<(u32, u32)> {
- if ihdr.len() != 13 {
- return None;
- }
- Some((
- u32::from_be_bytes(ihdr[0..4].try_into().ok()?),
- u32::from_be_bytes(ihdr[4..8].try_into().ok()?),
- ))
-}
-
-pub(super) fn test_media_limits() -> MediaLimits {
- MediaLimits::default_from_config()
-}
-
-pub(super) fn test_animation_limits() -> AnimationLimits {
- AnimationLimits::new(constants::MAX_ANIMATED_FRAMES_DEFAULT, 30_000)
- .expect("valid animation limits")
-}
-
-pub(super) fn animated_mode() -> AnimationMode {
- AnimationMode::Animated(test_animation_limits())
-}
-
-pub(super) fn effort(value: u8) -> EncodeEffort {
- EncodeEffort::parse_lenient(&value.to_string()).expect("valid encode effort")
-}
-
-pub(super) fn transform_image(
- input: &[u8],
- options: &ImageOptions,
-) -> Result<ProcessedMedia, MediaError> {
- super::super::transform_image(
- input,
- options,
- &test_media_limits(),
- &TransformMetrics::default(),
- )
-}
-
-pub(super) fn metadata_value(input: &[u8], _filename: &str) -> serde_json::Value {
- let meta = tokio::runtime::Builder::new_current_thread()
- .build()
- .unwrap()
- .block_on(async {
- finish_metadata(
- prepare_metadata(
- input,
- &MetadataOptions::default(),
- &test_media_limits(),
- &TransformMetrics::default(),
- )
- .expect("metadata prepares"),
- &NSFWClient::disabled(),
- )
- .await
- .unwrap()
- });
- serde_json::from_str(&meta).unwrap()
-}
-
-pub(super) fn assert_animated_webp(bytes: &[u8], frames: usize) {
- assert!(bytes.starts_with(b"RIFF"));
- assert_eq!(b"WEBP", &bytes[8..12]);
- assert_eq!(1, webp_chunk_payloads(bytes, b"ANIM").len());
- assert_eq!(frames, webp_chunk_payloads(bytes, b"ANMF").len());
-}
-
-pub(super) fn decode_rgba(bytes: &[u8]) -> (u32, u32, Vec<u8>) {
- ensure_vips_init().expect("libvips initialises");
- let options = CString::new("access=sequential").expect("static string has no NUL");
- let raw = unsafe {
- native::fluxer_vips_image_new_from_buffer(
- bytes.as_ptr().cast(),
- bytes.len(),
- options.as_ptr(),
- )
- };
- let image = unsafe { VipsImageHandle::from_raw_borrowing(raw, bytes) }.expect("decoded image");
- let width = unsafe { native::fluxer_vips_image_get_width(image.as_ptr()) as u32 };
- let height = unsafe { native::fluxer_vips_image_get_height(image.as_ptr()) as u32 };
- let mut rgba_ptr: *mut c_void = ptr::null_mut();
- let mut rgba_size: size_t = 0;
- let status = NativeStatus::from_code(unsafe {
- native::fluxer_vips_extract_rgba(image.as_ptr(), 0, &mut rgba_ptr, &mut rgba_size)
- });
- assert_eq!(NativeStatus::Ok, status);
- let rgba = unsafe { NativeBuffer::from_vips_owned(rgba_ptr, rgba_size) }.expect("rgba pixels");
- (width, height, rgba.as_slice().to_vec())
-}
diff --git a/fluxer_media_proxy/src/media_process/tests/heif.rs b/fluxer_media_proxy/src/media_process/tests/heif.rs
deleted file mode 100644
index 3fd64c84a..000000000
--- a/fluxer_media_proxy/src/media_process/tests/heif.rs
+++ /dev/null
@@ -1,254 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use super::super::image_probe::probe_image_dims;
-use super::super::{ImageDimensions, ImageOptions, ImageQuality, ResizeMode};
-use super::fixtures::{
- animated_mode, assert_animated_webp, decode_rgba, parse_png_chunks, test_media_limits,
- transform_image,
-};
-use crate::{
- metrics::transform::TransformMetrics, mime, output_format::OutputFormat,
- test_fixtures::webp_chunk_payloads,
-};
-use base64::Engine as _;
-
-#[test]
-fn animated_heic_sequence_decodes_every_frame_and_encodes_an_animation() {
- let sequence_b64 = "AAAAKGZ0eXBoZXZjAAAAAG1pZjFoZWljbWlhZm1zZjFpc29taGV2YwAAAtdtb292AAAAbG12aGQAAAAAAAAAAAAAAAAAAAAKAAAABAABAAABAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAACY3RyYWsAAABcdGtoZAAAAAcAAAAAAAAAAAAAAAEAAAAAAAAABAAAAAAAAAAAAAAAAAEAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAQAAAAEAAAAAAAf9tZGlhAAAAIG1kaGQAAAAAAAAAAAAAAAAAAAAKAAAABFXLAAAAAAAhaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAAAAAAG2bWluZgAAACRkaW5mAAAAHGRyZWYAAAAAAAAAAQAAAAx1cmwgAAAAAQAAAXZzdGJsAAAA7nN0c2QAAAAAAAAAAQAAAN5odmMxAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAEAAQABIAAAASAAAAAAAAAABBEhFVkMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGP//AAAAeGh2Y0MBAWAAAAAAAAAAAAAe8AD8/fj4AAAPA2AAAQAYQAEMAf//AWAAAAMAkAAAAwAAAwAeloCQYQABACtCAQEBYAAAAwCQAAADAAADAB6gIIEFllqSSmubgIaDAgAAAwAUAAADAAIQYgABAAdEAcFytCJAAAAAEGNjc3QAAAAAwAAAAAAAABhzdHRzAAAAAAAAAAEAAAAEAAAAAQAAABxzdHNjAAAAAAAAAAEAAAABAAAABAAAAAEAAAAkc3RzegAAAAAAAAAAAAAABAAAAB4AAAAUAAAAFgAAABcAAAAUc3RjbwAAAAAAAAABAAAEgwAAABRzdHNzAAAAAAAAAAEAAAABAAAAFHZtaGQAAAABAAAAAAAAAAAAAAFWbWV0YQAAAAAAAAAhaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAAAAAAAiaWxvYwAAAABEQAABAAEAAAAABF0AAQAAAAAAAAAeAAAAI2lpbmYAAAAAAAEAAAAVaW5mZQIAAAAAAQAAaHZjMQAAAAAOcGl0bQAAAAAAAQAAANZpcHJwAAAAt2lwY28AAAB4aHZjQwEDcAAAAAAAAAAAAB7wAPz9+PgAAA8DYAABABhAAQwB//8DcAAAAwCQAAADAAADAB66AkBhAAEAK0IBAQNwAAADAJAAAAMAAAMAHqAggQWW6kkprm4CGgwIAAADAMgAAAMACEBiAAEAB0QBwXKwIkAAAAATY29scm5jbHgAAQANAAaAAAAAFGlzcGUAAAAAAAAAQAAAAEAAAAAQcGl4aQAAAAADCAgIAAAAF2lwbWEAAAAAAAAAAQABBIECAwQAAAAmbWRhdAAAABooAa8J4CE5dV///sFn+9+qu//6bdHQcw9fgAAAAGdtZGF0AAAAGigBrwzgKGIep//+cn78j8uGP/9E0AcnMQj4AAAAEAIB0Al+KTYKhIVYOmGcqmIAAAASAgHQEf/UpKYKhITEg+YZQKpiAAAAEwIB0Bif/cpJGCwSFRIERhlAqmI=";
- let heic = base64::engine::general_purpose::STANDARD
- .decode(sequence_b64)
- .expect("fixture decodes");
- let sniffed = mime::sniff(&heic);
- assert_eq!("image/heic", sniffed.mime);
- assert!(!sniffed.animated);
-
- let animated = transform_image(
- &heic,
- &ImageOptions {
- format: OutputFormat::WebP,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .expect("animated heic transforms");
- assert_eq!("image/webp", animated.content_type);
- assert_animated_webp(&animated.bytes, 4);
- assert_eq!(
- ImageDimensions {
- width: 64,
- height: 64,
- pages: 4,
- bands: 3,
- eight_bit: true,
- },
- probe_image_dims(&test_media_limits(), &animated.bytes).expect("probes webp")
- );
-
- let mut heif = heic.clone();
- let ftyp_len = u32::from_be_bytes(heif[0..4].try_into().expect("ftyp length")) as usize;
- for brand in heif[8..ftyp_len].as_chunks_mut::<4>().0 {
- if brand == b"heic" || brand == b"hevc" {
- brand.copy_from_slice(b"msf1");
- }
- }
- assert_eq!("image/heif", mime::sniff(&heif).mime);
- let animated_heif = transform_image(
- &heif,
- &ImageOptions {
- format: OutputFormat::WebP,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .expect("animated heif transforms");
- assert_animated_webp(&animated_heif.bytes, 4);
-}
-
-#[test]
-fn still_heic_decodes_as_a_single_frame_when_animation_is_requested() {
- let still_b64 = "AAAAHGZ0eXBoZWljAAAAAG1pZjFoZWljbWlhZgAAAVZtZXRhAAAAAAAAACFoZGxyAAAAAAAAAABwaWN0AAAAAAAAAAAAAAAAAAAAACJpbG9jAAAAAERAAAEAAQAAAAABegABAAAAAAAAAB4AAAAjaWluZgAAAAAAAQAAABVpbmZlAgAAAAABAABodmMxAAAAAA5waXRtAAAAAAABAAAA1mlwcnAAAAC3aXBjbwAAAHhodmNDAQNwAAAAAAAAAAAAHvAA/P34+AAADwNgAAEAGEABDAH//wNwAAADAJAAAAMAAAMAHroCQGEAAQArQgEBA3AAAAMAkAAAAwAAAwAeoCCBBZbqSSmubgIaDAgAAAMAyAAAAwAIQGIAAQAHRAHBcrAiQAAAABNjb2xybmNseAABAA0ABoAAAAAUaXNwZQAAAAAAAABAAAAAQAAAABBwaXhpAAAAAAMICAgAAAAXaXBtYQAAAAAAAAABAAEEgQIDBAAAACZtZGF0AAAAGigBrwngITl1X//+wWf736q7//pt0dBzD1+A";
- let heic = base64::engine::general_purpose::STANDARD
- .decode(still_b64)
- .expect("fixture decodes");
- assert_eq!("image/heic", mime::sniff(&heic).mime);
-
- let still = transform_image(
- &heic,
- &ImageOptions {
- format: OutputFormat::WebP,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .expect("still heic transforms");
- assert_eq!("image/webp", still.content_type);
- assert!(webp_chunk_payloads(&still.bytes, b"ANIM").is_empty());
- assert_eq!(
- ImageDimensions {
- width: 64,
- height: 64,
- pages: 1,
- bands: 3,
- eight_bit: true,
- },
- probe_image_dims(&test_media_limits(), &still.bytes).expect("probes webp")
- );
-}
-
-#[test]
-fn avif_direct_decode_applies_resize_and_crop() {
- let fixture_b64 = "AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAAD5bWV0YQAAAAAAAAAvaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAFBpY3R1cmVIYW5kbGVyAAAAAA5waXRtAAAAAAABAAAAHmlsb2MAAAAARAAAAQABAAAAAQAAASEAAAFZAAAAKGlpbmYAAAAAAAEAAAAaaW5mZQIAAAAAAQAAYXYwMUNvbG9yAAAAAGppcHJwAAAAS2lwY28AAAAUaXNwZQAAAAAAAABAAAAAMAAAABBwaXhpAAAAAAMICAgAAAAMYXYxQ4EADAAAAAATY29scm5jbHgAAgACAAIAAAAAF2lwbWEAAAAAAAAAAQABBAECgwQAAAFhbWRhdAoGGBV/vbAIMs4CRgAABBBBQEqBANtxpEnkS8i7Ewu1Oa+E52+0gHxmN6DekBiIYovbIpo+I+L2MbaIuGgpmhiq3wmhtHx3Lyb9HWhe08jL3lTmL0L92z3pFGZiyNiXjoWSnt6Vs2YF9Ogt2S1YudcnVbcGESJSHNs+6UmubDO+hIB+aL08iAZr/qkVPsTgHY5xL3y7b0B4W8BuTdfXeVy/nJ8V2xmFc1fc4DXzEalW69hTvoJEKuitiwnHu32Gr1Qbjk88s36/tv1BQ2bbYX/QIFDJwLoME7YrHOzOB0zEmhjjdKZkNDwlG0u7YsB5EvaXAnkkgF6l5yaKb8tv2ZBYJO+kDNE7uK8kt5dEIlsrravn8byytjhCTzx5rRLwkj6obavPpIgh/z/z9mG1oxZ2zWugKXunGbw64JUJ+fUiTa2frsG0dGb02dKJ4rPXq9ZQY/B4G3nuZg==";
- let avif = base64::engine::general_purpose::STANDARD
- .decode(fixture_b64)
- .unwrap();
-
- let resized = transform_image(
- &avif,
- &ImageOptions {
- width: Some(32),
- format: OutputFormat::WebP,
- quality: ImageQuality::High,
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/webp", resized.content_type);
- assert_eq!(
- ImageDimensions {
- width: 32,
- height: 24,
- pages: 1,
- bands: 3,
- eight_bit: true,
- },
- probe_image_dims(&test_media_limits(), &resized.bytes).unwrap()
- );
-
- let cropped = transform_image(
- &avif,
- &ImageOptions {
- width: Some(32),
- height: Some(32),
- format: OutputFormat::PNG,
- quality: ImageQuality::High,
- resize_mode: ResizeMode::Cover,
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/png", cropped.content_type);
- assert_eq!(
- ImageDimensions {
- width: 32,
- height: 32,
- pages: 1,
- bands: 3,
- eight_bit: true,
- },
- probe_image_dims(&test_media_limits(), &cropped.bytes).unwrap()
- );
-}
-
-#[test]
-fn hdr_pq_avif_tone_maps_to_sdr_pixels() {
- let hdr_b64 = "AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAAD5bWV0YQAAAAAAAAAvaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAFBpY3R1cmVIYW5kbGVyAAAAAA5waXRtAAAAAAABAAAAHmlsb2MAAAAARAAAAQABAAAAAQAAASEAAAAkAAAAKGlpbmYAAAAAAAEAAAAaaW5mZQIAAAAAAQAAYXYwMUNvbG9yAAAAAGppcHJwAAAAS2lwY28AAAAUaXNwZQAAAAAAAABAAAAAMAAAABBwaXhpAAAAAAMKCgoAAAAMYXYxQ4EATAAAAAATY29scm5jbHgACQAQAAkAAAAAF2lwbWEAAAAAAAAAAQABBAECgwQAAAAsbWRhdAoOAgAABVV/vGr5UJEAkEAyEhAAhgAIIAAAABAABWqmwW/2MA==";
- let avif = base64::engine::general_purpose::STANDARD
- .decode(hdr_b64)
- .expect("fixture decodes");
- assert_eq!("image/avif", mime::sniff(&avif).mime);
- let metrics = TransformMetrics::default();
- let png = super::super::transform_image(
- &avif,
- &ImageOptions {
- format: OutputFormat::PNG,
- quality: ImageQuality::Lossless,
- ..Default::default()
- },
- &test_media_limits(),
- &metrics,
- )
- .expect("hdr avif transforms");
- assert_eq!("image/png", png.content_type);
- assert_eq!(1, metrics.hdr_tone_map_count());
- let chunks = parse_png_chunks(&png.bytes).expect("valid png");
- let ihdr = chunks.first().expect("png has chunks");
- assert_eq!(*b"IHDR", ihdr.kind);
- assert_eq!(
- 8, ihdr.data[8],
- "tone mapped output must be 8 bit per channel"
- );
- let (width, height, rgba) = decode_rgba(&png.bytes);
- assert_eq!((64, 48), (width, height));
- let centre = ((height as usize / 2) * width as usize + width as usize / 2) * 4;
- let expected = [166u8, 160, 165, 255];
- for (channel, value) in expected.iter().enumerate() {
- assert!(
- rgba[centre + channel].abs_diff(*value) <= 3,
- "channel {channel} tone mapped to {} instead of {value}",
- rgba[centre + channel]
- );
- }
- assert!(
- rgba[centre] >= 150,
- "a PQ mid grey read as plain sRGB would land near 128, got {}",
- rgba[centre]
- );
- for pixel in rgba.as_chunks::<4>().0 {
- assert_eq!(255, pixel[3], "tone mapped output must stay opaque");
- for channel in 0..3 {
- assert!(
- pixel[channel].abs_diff(expected[channel]) <= 8,
- "flat source produced {pixel:?}"
- );
- }
- }
-}
-
-#[test]
-fn hdr_pq_avif_tone_maps_even_when_the_colour_signal_is_one_libheif_cannot_model() {
- let hdr_icc_b64 = "AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAAGObWV0YQAAAAAAAAAvaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAFBpY3R1cmVIYW5kbGVyAAAAAA5waXRtAAAAAAABAAAAHmlsb2MAAAAARAAAAQABAAAAAQAAAbYAAAAkAAAAKGlpbmYAAAAAAAEAAAAaaW5mZQIAAAAAAQAAYXYwMUNvbG9yAAAAAP9pcHJwAAAA32lwY28AAAAUaXNwZQAAAAAAAABAAAAAMAAAABBwaXhpAAAAAAMKCgoAAAAMYXYxQ4EATAAAAAATY29scm5jbHgACQAQAAkAAAAAlGNvbHJwcm9mAAAAiG5vbmUEMAAAbW50clJHQiBYWVogAAAAAAAAAAAAAAAAYWNzcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhpcG1hAAAAAAAAAAEAAQUBAoMEBQAAACxtZGF0Cg4CAAAFVX+8avlQkQCQQDISEACGAAggAAAAEAAFaqbBb/Yw";
- let avif = base64::engine::general_purpose::STANDARD
- .decode(hdr_icc_b64)
- .expect("fixture decodes");
- assert_eq!("image/avif", mime::sniff(&avif).mime);
- let nclx = avif
- .windows(8)
- .position(|window| window == b"colrnclx")
- .expect("fixture has an nclx colour box");
- assert!(
- avif.windows(8).any(|window| window == b"colrprof"),
- "fixture has an icc colour box"
- );
- let mut cases = vec![("an icc profile", avif.clone())];
- for (label, offset) in [
- ("unspecified primaries", nclx + 8),
- ("unspecified matrix coefficients", nclx + 12),
- ] {
- let mut mutated = avif.clone();
- mutated[offset..offset + 2].copy_from_slice(&2u16.to_be_bytes());
- cases.push((label, mutated));
- }
- for (label, bytes) in cases {
- let metrics = TransformMetrics::default();
- let png = super::super::transform_image(
- &bytes,
- &ImageOptions {
- format: OutputFormat::PNG,
- quality: ImageQuality::Lossless,
- ..Default::default()
- },
- &test_media_limits(),
- &metrics,
- )
- .unwrap_or_else(|error| panic!("hdr avif with {label} transforms: {error:?}"));
- assert_eq!(1, metrics.hdr_tone_map_count(), "hdr avif with {label}");
- let (width, height, rgba) = decode_rgba(&png.bytes);
- assert_eq!((64, 48), (width, height), "hdr avif with {label}");
- let centre = ((height as usize / 2) * width as usize + width as usize / 2) * 4;
- assert!(
- rgba[centre] >= 150,
- "hdr avif with {label} read its PQ samples as plain sRGB and landed at {}",
- rgba[centre]
- );
- }
-}
diff --git a/fluxer_media_proxy/src/media_process/tests/metadata.rs b/fluxer_media_proxy/src/media_process/tests/metadata.rs
deleted file mode 100644
index 65ee9e24b..000000000
--- a/fluxer_media_proxy/src/media_process/tests/metadata.rs
+++ /dev/null
@@ -1,325 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use super::super::nsfw_processing::{VideoNSFWFramesRequest, extract_video_frames_for_nsfw};
-use super::super::placeholder::optional_thumbhash;
-use super::super::{
- AV_NATIVE_COST_BYTES, MediaError, MetadataOptions, NSFW_PREVIEW_MAX_DIMENSION, NativeCost,
- extract_video_thumbnail, finish_metadata, metadata_cost, prepare_metadata, probe_av_metadata,
-};
-use super::fixtures::{metadata_value, test_media_limits};
-use crate::{
- constants,
- metrics::transform::TransformMetrics,
- mime,
- nsfw::{NSFWClient, NSFWPolicy},
- output_format::OutputFormat,
- test_fixtures::{
- JXL_4100_LOSSLESS_RGB16, JXL_4100_LOSSY_ALPHA, JXL_4100_LOSSY_RGB_DEPTH,
- JXL_7000X4000_LOSSY_RGB, fixture_audio_mp3_with_png_cover_art,
- fixture_audio_mp4_with_attached_picture, fixture_audio_only_mp4, fixture_h264_mp4,
- fixture_mkv_with_png_video_stream, fixture_mp4_with_undecodable_video, synthetic_png,
- synthetic_wav,
- },
-};
-use std::{io::Write as _, sync::Arc};
-
-fn mapped_past_the_buffer_bound(head: &[u8]) -> memmap2::Mmap {
- let mut file = tempfile::tempfile().expect("temp file");
- file.write_all(head).expect("written head");
- file.set_len(constants::MAX_MEDIA_PROXY_BYTES as u64 + 1)
- .expect("sparse tail");
- unsafe { memmap2::Mmap::map(&file).expect("mapped file") }
-}
-
-#[test]
-fn metadata_json_includes_dimensions_and_placeholder() {
- let png = synthetic_png(16, 16);
- let meta = tokio::runtime::Builder::new_current_thread()
- .build()
- .unwrap()
- .block_on(async {
- finish_metadata(
- prepare_metadata(
- &png,
- &MetadataOptions::default(),
- &test_media_limits(),
- &TransformMetrics::default(),
- )
- .expect("metadata prepares"),
- &NSFWClient::disabled(),
- )
- .await
- .unwrap()
- });
- assert!(meta.contains("\"format\":\"png\""));
- assert!(meta.contains("\"width\":16"));
- assert!(meta.contains("\"height\":16"));
- assert!(meta.contains("\"placeholder\":\""));
- assert!(meta.contains("\"nsfw\":false"));
- assert!(meta.contains("\"nsfw_probability\":0"));
-}
-
-#[test]
-fn metadata_json_returns_unavailable_when_nsfw_service_fails() {
- let png = synthetic_png(16, 16);
- let err = tokio::runtime::Builder::new_current_thread()
- .enable_all()
- .build()
- .unwrap()
- .block_on(async {
- let client = NSFWClient::new(
- "http://127.0.0.1:9",
- 0.85,
- Arc::new(crate::metrics::nsfw::NSFWMetrics::default()),
- )
- .expect("nsfw client builds");
- finish_metadata(
- prepare_metadata(
- &png,
- &MetadataOptions {
- placeholder: false,
- nsfw: NSFWPolicy::enabled(0.85).expect("valid threshold"),
- deadline_ms: None,
- },
- &test_media_limits(),
- &TransformMetrics::default(),
- )
- .expect("metadata prepares"),
- &client,
- )
- .await
- .unwrap_err()
- });
- assert_eq!(err, MediaError::NsfwScanUnavailable);
-}
-
-#[test]
-fn metadata_json_uses_null_dimensions_for_audio() {
- let wav = synthetic_wav();
- let value = metadata_value(&wav, "test.wav");
- assert_eq!(value["content_type"], "audio/wav");
- assert_eq!(value.get("width"), Some(&serde_json::Value::Null));
- assert_eq!(value.get("height"), Some(&serde_json::Value::Null));
- assert_eq!(value["duration"], 1);
-}
-
-#[test]
-fn metadata_json_classifies_audio_only_mp4_as_audio() {
- let mp4 = fixture_audio_only_mp4();
- assert_eq!("video/mp4", mime::sniff(&mp4).mime);
- let value = metadata_value(&mp4, "renamed.mp4");
- assert_eq!(value["content_type"], "audio/mp4");
- assert_eq!(value["format"], "m4a");
- assert_eq!(value.get("width"), Some(&serde_json::Value::Null));
- assert_eq!(value.get("height"), Some(&serde_json::Value::Null));
- assert_eq!(value["duration"], 1);
-}
-
-#[test]
-fn metadata_json_treats_mp4_attached_picture_as_audio_cover_art() {
- let mp4 = fixture_audio_mp4_with_attached_picture();
- let probe = probe_av_metadata(&mp4, NSFW_PREVIEW_MAX_DIMENSION, &test_media_limits(), None)
- .expect("audio mp4 probes")
- .probe;
- assert!(probe.has_audio);
- assert!(!probe.has_video);
- let value = metadata_value(&mp4, "renamed.mp4");
- assert_eq!(value["content_type"], "audio/mp4");
- assert_eq!(value["format"], "m4a");
- assert_eq!(value.get("width"), Some(&serde_json::Value::Null));
- assert_eq!(value.get("height"), Some(&serde_json::Value::Null));
-}
-
-#[test]
-fn metadata_json_accepts_audio_with_png_cover_art() {
- let mp3 = fixture_audio_mp3_with_png_cover_art();
- assert_eq!("audio/mpeg", mime::sniff(&mp3).mime);
- let probe = probe_av_metadata(&mp3, NSFW_PREVIEW_MAX_DIMENSION, &test_media_limits(), None)
- .expect("audio with png cover art probes")
- .probe;
- assert!(probe.has_audio);
- assert!(!probe.has_video);
- let value = metadata_value(&mp3, "cover.mp3");
- assert_eq!(value["content_type"], "audio/mpeg");
- assert_eq!(value["format"], "mp3");
- assert_eq!(value["size"], mp3.len());
- assert_eq!(value.get("width"), Some(&serde_json::Value::Null));
- assert_eq!(value.get("height"), Some(&serde_json::Value::Null));
- assert_eq!(value["animated"], false);
- assert_eq!(value["duration"], 1);
- assert_eq!(None, value.get("placeholder"));
-}
-
-#[test]
-fn metadata_json_degrades_when_the_video_frame_fails_to_decode() {
- let intact = fixture_h264_mp4();
- let intact_value = metadata_value(&intact, "intact.mp4");
- assert_eq!(intact_value["width"], 16);
- assert_eq!(intact_value["height"], 16);
-
- let broken = fixture_mp4_with_undecodable_video();
- assert_eq!(
- Some(MediaError::MediaDecodeFailed),
- probe_av_metadata(
- &broken,
- NSFW_PREVIEW_MAX_DIMENSION,
- &test_media_limits(),
- None
- )
- .err()
- );
- let value = metadata_value(&broken, "broken.mp4");
- assert_eq!(value["content_type"], "video/mp4");
- assert_eq!(value["format"], "mp4");
- assert_eq!(value.get("width"), Some(&serde_json::Value::Null));
- assert_eq!(value.get("height"), Some(&serde_json::Value::Null));
- assert_eq!(None, value.get("placeholder"));
-}
-
-#[test]
-fn metadata_json_still_rejects_a_playable_video_stream_outside_the_codec_allowlist() {
- let mkv = fixture_mkv_with_png_video_stream();
- assert_eq!("video/x-matroska", mime::sniff(&mkv).mime);
- assert_eq!(
- Some(MediaError::MediaDecodeFailed),
- probe_av_metadata(&mkv, NSFW_PREVIEW_MAX_DIMENSION, &test_media_limits(), None).err()
- );
- let err = tokio::runtime::Builder::new_current_thread()
- .build()
- .unwrap()
- .block_on(async {
- prepare_metadata(
- &mkv,
- &MetadataOptions::default(),
- &test_media_limits(),
- &TransformMetrics::default(),
- )
- .err()
- .expect("metadata preparation fails")
- });
- assert_eq!(MediaError::MediaDecodeFailed, err);
-}
-
-#[test]
-fn metadata_keeps_the_placeholder_for_every_aspect_ratio() {
- for (width, height, filename) in [
- (64, 64, "square.png"),
- (800, 50, "wide.png"),
- (1000, 100, "banner.png"),
- (100, 1000, "tall.png"),
- ] {
- let value = metadata_value(&synthetic_png(width, height), filename);
- assert_eq!(width, value["width"]);
- assert_eq!(height, value["height"]);
- assert!(
- value["placeholder"]
- .as_str()
- .is_some_and(|placeholder| !placeholder.is_empty()),
- "{filename} should keep its placeholder"
- );
- }
-}
-
-#[test]
-fn metadata_omits_the_placeholder_when_thumbhash_allocation_fails() {
- assert_eq!(
- None,
- optional_thumbhash(Err(MediaError::AllocationFailed), "image_metadata")
- );
- assert_eq!(
- None,
- optional_thumbhash(Err(MediaError::MediaTransformFailed), "video_metadata")
- );
-}
-
-#[test]
-fn metadata_succeeds_without_a_placeholder_when_thumbhash_generation_fails() {
- let mut png = synthetic_png(64, 64);
- let idat = png
- .windows(4)
- .position(|window| window == b"IDAT")
- .expect("synthetic png has an IDAT chunk");
- png.truncate(idat + 8);
- let value = metadata_value(&png, "truncated.png");
- assert_eq!("image/png", value["content_type"]);
- assert_eq!(64, value["width"]);
- assert_eq!(64, value["height"]);
- assert_eq!(None, value.get("placeholder"));
-}
-
-#[test]
-fn metadata_refuses_jxl_above_the_decode_pixel_cap() {
- for jxl in [
- JXL_4100_LOSSY_ALPHA,
- JXL_4100_LOSSY_RGB_DEPTH,
- JXL_4100_LOSSLESS_RGB16,
- ] {
- let err = prepare_metadata(
- jxl,
- &MetadataOptions::default(),
- &test_media_limits(),
- &TransformMetrics::default(),
- )
- .err()
- .expect("metadata preparation fails");
- assert_eq!(MediaError::TooLargeToProcess, err);
- }
-}
-
-#[test]
-fn metadata_admits_8_bit_rgb_jxl_above_the_decode_pixel_cap() {
- let value = metadata_value(JXL_7000X4000_LOSSY_RGB, "big.jxl");
- assert_eq!("image/jxl", value["content_type"]);
- assert_eq!(7000, value["width"]);
- assert_eq!(4000, value["height"]);
- assert!(value["placeholder"].as_str().is_some_and(|p| !p.is_empty()));
-}
-
-#[test]
-fn metadata_refuses_an_image_past_the_buffer_bound() {
- let png = mapped_past_the_buffer_bound(&synthetic_png(16, 16));
- assert_eq!("image/png", mime::sniff(&png).mime);
- let err = tokio::runtime::Builder::new_current_thread()
- .build()
- .unwrap()
- .block_on(async {
- prepare_metadata(
- &png,
- &MetadataOptions::default(),
- &test_media_limits(),
- &TransformMetrics::default(),
- )
- .err()
- .expect("metadata preparation fails")
- });
- assert_eq!(MediaError::StreamTooLong, err);
-}
-
-#[test]
-fn native_cost_of_a_video_past_the_buffer_bound_leaves_out_the_mapped_tail() {
- let mp4 = mapped_past_the_buffer_bound(&fixture_h264_mp4());
- assert_eq!(
- NativeCost::UpToBudget(constants::MAX_MEDIA_PROXY_BYTES + AV_NATIVE_COST_BYTES),
- metadata_cost(&mp4, &test_media_limits()).expect("video cost")
- );
-}
-
-#[test]
-fn video_reads_accept_an_input_past_the_buffer_bound() {
- let mp4 = mapped_past_the_buffer_bound(&fixture_h264_mp4());
- let limits = test_media_limits();
-
- let probe = probe_av_metadata(&mp4, NSFW_PREVIEW_MAX_DIMENSION, &limits, None)
- .expect("probed video")
- .probe;
- assert!(probe.has_video);
- let poster = extract_video_thumbnail(&mp4, OutputFormat::WebP, &limits).expect("poster frame");
- assert_eq!("image/webp", mime::sniff(&poster.bytes).mime);
- let frames = extract_video_frames_for_nsfw(VideoNSFWFramesRequest {
- input: &mp4,
- duration_seconds: probe.duration_seconds,
- deadline_ms: None,
- })
- .expect("sampled frames");
- assert!(!frames.is_empty());
-}
diff --git a/fluxer_media_proxy/src/media_process/tests/transform.rs b/fluxer_media_proxy/src/media_process/tests/transform.rs
deleted file mode 100644
index 9243a9689..000000000
--- a/fluxer_media_proxy/src/media_process/tests/transform.rs
+++ /dev/null
@@ -1,314 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use super::super::image_probe::{load_image, probe_image_dims};
-use super::super::loaded_image::validate_jxl_decode_pixels;
-use super::super::native_runtime::ensure_vips_init;
-use super::super::{ImageDimensions, ImageOptions, MediaError, NativeCost, image_transform_cost};
-use super::fixtures::{animated_mode, metadata_value, test_media_limits, transform_image};
-use crate::{
- constants,
- metrics::transform::TransformMetrics,
- mime, native,
- output_format::OutputFormat,
- test_fixtures::{
- JPEG_ROTATED_MISMATCHED_SCAN, JXL_64_LOSSY_ALPHA, JXL_4100_LOSSLESS_RGB16,
- JXL_4100_LOSSY_ALPHA, JXL_4100_LOSSY_RGB_DEPTH, JXL_7000X4000_LOSSY_RGB, png_dimensions,
- synthetic_bmp, synthetic_png,
- },
-};
-
-#[test]
-fn transforms_static_png_with_animated_flag_does_not_pass_n_to_pngload() {
- let png = synthetic_png(48, 48);
- let out = transform_image(
- &png,
- &ImageOptions {
- width: Some(32),
- height: Some(32),
- format: OutputFormat::WebP,
- animation: animated_mode(),
- ..Default::default()
- },
- )
- .expect("static-png + animated=true must transform without erroring");
- assert_eq!("image/webp", out.content_type);
- assert!(out.bytes.starts_with(b"RIFF"));
-}
-
-#[test]
-fn transforms_a_24_bit_bmp_to_webp_without_unblocking_imagemagick() {
- ensure_vips_init().expect("vips must initialise");
- let bmp = synthetic_bmp(4, 4);
- assert_eq!("image/bmp", mime::sniff(&bmp).mime);
- assert!(mime::is_supported_media_mime("image/bmp"));
- assert!(
- load_image(&bmp, "access=sequential,fail=true").is_err(),
- "the libvips loader allowlist must keep ImageMagick blocked for bmp"
- );
- let out = transform_image(
- &bmp,
- &ImageOptions {
- format: OutputFormat::WebP,
- ..Default::default()
- },
- )
- .expect("a 24-bit bmp must transform end to end");
- assert_eq!("image/webp", out.content_type);
- assert!(out.bytes.starts_with(b"RIFF"));
- assert_eq!(
- Some(b"WEBP"),
- out.bytes.get(8..12).map(|tag| tag.try_into().unwrap())
- );
- let decoded =
- load_image(&out.bytes, "access=sequential,fail=true").expect("output must be webp");
- assert_eq!(4, unsafe {
- native::fluxer_vips_image_get_width(decoded.as_ptr())
- });
- assert_eq!(4, unsafe {
- native::fluxer_vips_image_get_height(decoded.as_ptr())
- });
-}
-
-#[test]
-fn reports_bmp_metadata_dimensions_and_placeholder() {
- let bmp = synthetic_bmp(64, 48);
- let meta = metadata_value(&bmp, "photo.bmp");
- assert_eq!("image/bmp", meta["content_type"]);
- assert_eq!("bmp", meta["format"]);
- assert_eq!(64, meta["width"]);
- assert_eq!(48, meta["height"]);
- assert_eq!(false, meta["animated"]);
- assert!(meta["placeholder"].as_str().is_some_and(|p| !p.is_empty()));
-}
-
-#[test]
-fn refuses_jxl_above_the_decode_pixel_cap_before_decoding() {
- for jxl in [
- JXL_4100_LOSSY_ALPHA,
- JXL_4100_LOSSY_RGB_DEPTH,
- JXL_4100_LOSSLESS_RGB16,
- ] {
- for width in [None, Some(128)] {
- let err = transform_image(
- jxl,
- &ImageOptions {
- width,
- format: OutputFormat::WebP,
- ..Default::default()
- },
- )
- .unwrap_err();
- assert_eq!(MediaError::TooLargeToProcess, err);
- }
- }
-}
-
-#[test]
-fn jxl_decode_cap_depends_on_the_header_layout() {
- let dims = |width, height, pages, bands, eight_bit| ImageDimensions {
- width,
- height,
- pages,
- bands,
- eight_bit,
- };
- let simple_cap = (8192, 6144);
- let complex_cap = (4096, 4096);
- for bands in [1, 3] {
- let (width, height) = simple_cap;
- assert_eq!(
- Ok(()),
- validate_jxl_decode_pixels("image/jxl", dims(width, height, 1, bands, true))
- );
- assert_eq!(
- Err(MediaError::TooLargeToProcess),
- validate_jxl_decode_pixels("image/jxl", dims(width, height + 1, 1, bands, true))
- );
- }
- for (pages, bands, eight_bit) in [(1, 2, true), (1, 4, true), (1, 3, false), (2, 3, true)] {
- let (width, height) = complex_cap;
- assert_eq!(
- Ok(()),
- validate_jxl_decode_pixels(
- "image/jxl",
- dims(width, height / pages, pages, bands, eight_bit)
- )
- );
- assert_eq!(
- Err(MediaError::TooLargeToProcess),
- validate_jxl_decode_pixels(
- "image/jxl",
- dims(width, height / pages + 1, pages, bands, eight_bit)
- )
- );
- }
- assert_eq!(
- Ok(()),
- validate_jxl_decode_pixels("image/png", dims(16384, 16384, 1, 4, false))
- );
-}
-
-#[test]
-fn thumbnails_8_bit_rgb_jxl_above_the_decode_pixel_cap() {
- let out = transform_image(
- JXL_7000X4000_LOSSY_RGB,
- &ImageOptions {
- width: Some(550),
- format: OutputFormat::WebP,
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/webp", out.content_type);
- let dims = probe_image_dims(&test_media_limits(), &out.bytes).unwrap();
- assert_eq!((550, 314), (dims.width, dims.height));
-}
-
-#[test]
-fn full_size_jxl_above_the_static_output_cap_is_downscaled_to_fit() {
- let options = ImageOptions {
- format: OutputFormat::WebP,
- ..Default::default()
- };
- let out = transform_image(JXL_7000X4000_LOSSY_RGB, &options).unwrap();
- assert_eq!("image/webp", out.content_type);
- let dims = probe_image_dims(&test_media_limits(), &out.bytes).unwrap();
- assert_eq!((6636, 3792), (dims.width, dims.height));
- assert!(dims.width as usize * dims.height as usize <= constants::MAX_STATIC_OUTPUT_PIXELS);
-
- let cost =
- image_transform_cost(JXL_7000X4000_LOSSY_RGB, &options, &test_media_limits()).unwrap();
- assert_eq!(
- NativeCost::Bytes(JXL_7000X4000_LOSSY_RGB.len() + 7000 * 4000 * 40 + 6636 * 3792 * 28),
- cost
- );
-}
-
-#[test]
-fn full_size_jxl_is_downscaled_to_fit_the_native_memory_budget() {
- let options = ImageOptions {
- format: OutputFormat::WebP,
- ..Default::default()
- };
- let decode = JXL_7000X4000_LOSSY_RGB.len() + 7000 * 4000 * 40;
- let budget = decode + 10_000_000 * 28;
- let media_limits = test_media_limits().with_native_memory_budget(budget);
- let out = super::super::transform_image(
- JXL_7000X4000_LOSSY_RGB,
- &options,
- &media_limits,
- &TransformMetrics::default(),
- )
- .unwrap();
- let dims = probe_image_dims(&test_media_limits(), &out.bytes).unwrap();
- assert_eq!((4183, 2390), (dims.width, dims.height));
- assert_eq!(
- NativeCost::Bytes(decode + 4183 * 2390 * 28),
- image_transform_cost(JXL_7000X4000_LOSSY_RGB, &options, &media_limits).unwrap()
- );
-}
-
-#[test]
-fn transforms_jxl_within_the_decode_pixel_cap() {
- let out = transform_image(
- JXL_64_LOSSY_ALPHA,
- &ImageOptions {
- width: Some(32),
- format: OutputFormat::WebP,
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!("image/webp", out.content_type);
-}
-
-#[test]
-fn refuses_full_size_svg_raster_above_the_static_output_cap() {
- let svg = br#"<svg xmlns="http://www.w3.org/2000/svg" width="16383" height="16383"></svg>"#;
- let err = transform_image(
- svg,
- &ImageOptions {
- format: OutputFormat::WebP,
- ..Default::default()
- },
- )
- .unwrap_err();
- assert_eq!(MediaError::TooLargeToProcess, err);
- let err = transform_image(
- svg,
- &ImageOptions {
- width: Some(16384),
- format: OutputFormat::WebP,
- ..Default::default()
- },
- )
- .unwrap_err();
- assert_eq!(MediaError::TooLargeToProcess, err);
-}
-
-#[test]
-fn rasterizes_large_svg_into_a_bounded_box() {
- let svg = br#"<svg xmlns="http://www.w3.org/2000/svg" width="16383" height="16383"></svg>"#;
- let out = transform_image(
- svg,
- &ImageOptions {
- width: Some(64),
- height: Some(64),
- format: OutputFormat::PNG,
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!(Some((64, 64)), png_dimensions(&out.bytes));
-}
-
-#[test]
-fn transform_cost_charges_the_full_source_decode_for_jxl() {
- let cost = image_transform_cost(
- JXL_4100_LOSSY_ALPHA,
- &ImageOptions {
- width: Some(128),
- format: OutputFormat::WebP,
- ..Default::default()
- },
- &super::fixtures::test_media_limits(),
- )
- .unwrap();
- let NativeCost::Bytes(cost) = cost else {
- panic!("an image is charged exact bytes")
- };
- assert!(cost >= 4100 * 4100 * 40, "cost {cost}");
-}
-
-#[test]
-fn transform_cost_charges_svg_at_its_output_size() {
- let svg = br#"<svg xmlns="http://www.w3.org/2000/svg" width="16383" height="16383"></svg>"#;
- let cost = image_transform_cost(
- svg,
- &ImageOptions {
- width: Some(64),
- height: Some(64),
- format: OutputFormat::WebP,
- ..Default::default()
- },
- &super::fixtures::test_media_limits(),
- )
- .unwrap();
- let NativeCost::Bytes(cost) = cost else {
- panic!("an image is charged exact bytes")
- };
- assert!(cost < 1 << 20, "cost {cost}");
-}
-
-#[test]
-fn transforms_a_rotated_jpeg_with_mismatched_scan_headers_at_full_size() {
- let out = transform_image(
- JPEG_ROTATED_MISMATCHED_SCAN,
- &ImageOptions {
- format: OutputFormat::PNG,
- ..Default::default()
- },
- )
- .unwrap();
- assert_eq!(Some((768, 1024)), png_dimensions(&out.bytes));
-}
diff --git a/fluxer_media_proxy/src/media_process/tests/video.rs b/fluxer_media_proxy/src/media_process/tests/video.rs
deleted file mode 100644
index ea3dec96c..000000000
--- a/fluxer_media_proxy/src/media_process/tests/video.rs
+++ /dev/null
@@ -1,555 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use super::super::{
- MediaError, VideoThumbnailOptions, extract_video_thumbnail,
- extract_video_thumbnail_with_options,
-};
-use super::fixtures::{decode_rgba, metadata_value, test_media_limits};
-use crate::{
- image_quality::ResolvedImageQuality,
- output_format::OutputFormat,
- test_fixtures::{
- ffmpeg_gen_media, ffmpeg_gen_mp4, ffmpeg_gen_rotated_mp4, ffmpeg_mirror_mp4, png_dimensions,
- },
-};
-
-fn color_tagged_video(primaries: &str, transfer: &str, matrix: &str) -> Option<Vec<u8>> {
- let params =
- format!("setparams=color_primaries={primaries}:color_trc={transfer}:colorspace={matrix}");
- ffmpeg_gen_media(
- "fixture.mkv",
- &[
- "-f",
- "lavfi",
- "-i",
- "testsrc=size=320x240:rate=10:duration=1",
- "-vf",
- &params,
- "-pix_fmt",
- "yuv420p",
- "-c:v",
- "mpeg4",
- "-f",
- "matroska",
- ],
- )
-}
-
-#[test]
-fn video_thumbnail_accepts_smpte170m_sd_primaries() {
- let Some(video) = color_tagged_video("smpte170m", "smpte170m", "smpte170m") else {
- eprintln!("skipping: ffmpeg CLI not available");
- return;
- };
- let thumb = extract_video_thumbnail(&video, OutputFormat::PNG, &test_media_limits())
- .expect("ntsc sd video should thumbnail");
- assert_eq!(png_dimensions(&thumb.bytes), Some((320, 240)));
-}
-
-#[test]
-fn video_thumbnail_accepts_bt470bg_pal_primaries() {
- let Some(video) = color_tagged_video("bt470bg", "bt470bg", "bt470bg") else {
- eprintln!("skipping: ffmpeg CLI not available");
- return;
- };
- let thumb = extract_video_thumbnail(&video, OutputFormat::PNG, &test_media_limits())
- .expect("pal sd video should thumbnail");
- assert_eq!(png_dimensions(&thumb.bytes), Some((320, 240)));
-
- let film = color_tagged_video("film", "bt470m", "bt470bg").expect("film fixture");
- let thumb = extract_video_thumbnail(&film, OutputFormat::PNG, &test_media_limits())
- .expect("film primaries should thumbnail");
- assert_eq!(png_dimensions(&thumb.bytes), Some((320, 240)));
-}
-
-#[test]
-fn a_bt709_thumbnail_keeps_the_source_shadow_luminance() {
- let Some(video) = ffmpeg_gen_media(
- "shadow.mkv",
- &[
- "-f",
- "lavfi",
- "-i",
- "color=c=0x181818:size=320x240:rate=10:duration=1",
- "-vf",
- "setparams=color_primaries=bt709:color_trc=bt709:colorspace=bt709:range=tv",
- "-pix_fmt",
- "yuv420p",
- "-c:v",
- "mpeg4",
- "-f",
- "matroska",
- ],
- ) else {
- eprintln!("skipping: ffmpeg CLI not available");
- return;
- };
- let thumb = extract_video_thumbnail(&video, OutputFormat::PNG, &test_media_limits())
- .expect("bt709 shadow video should thumbnail");
- let (_, _, pixels) = decode_rgba(&thumb.bytes);
- let luma: Vec<f64> = pixels
- .as_chunks::<4>()
- .0
- .iter()
- .map(|p| 0.2126 * f64::from(p[0]) + 0.7152 * f64::from(p[1]) + 0.0722 * f64::from(p[2]))
- .collect();
- let mean = luma.iter().sum::<f64>() / luma.len() as f64;
- assert!(
- (mean - 24.0).abs() <= 8.0,
- "a bt709 source must not be lifted by a transfer conversion: mean luminance {mean}"
- );
-}
-
-#[test]
-fn video_thumbnail_accepts_every_widened_sdr_transfer() {
- let transfers = ["smpte240m", "linear", "iec61966-2-1", "bt470m", "bt470bg"];
- let Some(first) = color_tagged_video("bt709", transfers[0], "bt709") else {
- eprintln!("skipping: ffmpeg CLI not available");
- return;
- };
- for (index, transfer) in transfers.iter().enumerate() {
- let video = if index == 0 {
- first.clone()
- } else {
- color_tagged_video("bt709", transfer, "bt709")
- .unwrap_or_else(|| panic!("{transfer} fixture"))
- };
- let thumb = extract_video_thumbnail(&video, OutputFormat::PNG, &test_media_limits())
- .unwrap_or_else(|error| panic!("{transfer} should thumbnail: {error:?}"));
- assert_eq!(png_dimensions(&thumb.bytes), Some((320, 240)), "{transfer}");
- }
-}
-
-#[test]
-fn video_thumbnail_tone_maps_hdr_instead_of_refusing_it() {
- let Some(hdr) = color_tagged_video("bt2020", "smpte2084", "bt2020nc") else {
- eprintln!("skipping: ffmpeg CLI not available");
- return;
- };
- let thumb = extract_video_thumbnail(&hdr, OutputFormat::PNG, &test_media_limits())
- .expect("pq bt2020 video should thumbnail");
- assert_eq!(png_dimensions(&thumb.bytes), Some((320, 240)));
-
- for (primaries, transfer, matrix) in [
- ("bt709", "smpte2084", "bt709"),
- ("bt2020", "arib-std-b67", "bt709"),
- ("bt2020", "arib-std-b67", "bt2020nc"),
- ("bt2020", "bt709", "bt709"),
- ("smpte432", "bt709", "bt709"),
- ] {
- let video = color_tagged_video(primaries, transfer, matrix)
- .unwrap_or_else(|| panic!("{primaries}/{transfer}/{matrix} fixture"));
- let thumb = extract_video_thumbnail(&video, OutputFormat::PNG, &test_media_limits())
- .unwrap_or_else(|error| {
- panic!("{primaries}/{transfer}/{matrix} should thumbnail: {error:?}")
- });
- assert_eq!(
- png_dimensions(&thumb.bytes),
- Some((320, 240)),
- "{primaries}/{transfer}/{matrix}"
- );
- }
-}
-
-#[test]
-fn hdr_video_thumbnail_still_errors_on_an_expired_deadline() {
- let Some(hdr) = color_tagged_video("bt2020", "smpte2084", "bt2020nc") else {
- eprintln!("skipping: ffmpeg CLI not available");
- return;
- };
- assert!(matches!(
- extract_video_thumbnail_with_options(
- &hdr,
- VideoThumbnailOptions {
- format: OutputFormat::PNG,
- width: None,
- height: None,
- quality: ResolvedImageQuality::High,
- deadline_ms: Some(1),
- },
- &test_media_limits(),
- ),
- Err(MediaError::RequestTimeout)
- ));
-}
-
-#[test]
-fn video_thumbnail_still_rejects_colour_signals_it_cannot_model() {
- let Some(cinema_transfer) = color_tagged_video("bt709", "smpte428", "bt709") else {
- eprintln!("skipping: ffmpeg CLI not available");
- return;
- };
- assert_eq!(
- Some(MediaError::MediaDecodeFailed),
- extract_video_thumbnail(&cinema_transfer, OutputFormat::PNG, &test_media_limits()).err()
- );
-
- let cinema_primaries =
- color_tagged_video("smpte428", "bt709", "bt709").expect("smpte428 primaries fixture");
- assert_eq!(
- Some(MediaError::MediaDecodeFailed),
- extract_video_thumbnail(&cinema_primaries, OutputFormat::PNG, &test_media_limits()).err()
- );
-}
-
-fn flat_colour_tagged_video(
- colour: &str,
- primaries: &str,
- transfer: &str,
- matrix: &str,
-) -> Option<Vec<u8>> {
- let params =
- format!("setparams=color_primaries={primaries}:color_trc={transfer}:colorspace={matrix}");
- ffmpeg_gen_media(
- "fixture.mkv",
- &[
- "-f",
- "lavfi",
- "-i",
- &format!("color=c={colour}:size=320x240:rate=10:duration=1"),
- "-vf",
- &params,
- "-pix_fmt",
- "yuv420p",
- "-c:v",
- "mpeg4",
- "-qscale:v",
- "1",
- "-f",
- "matroska",
- ],
- )
-}
-
-fn flat_colour_centre_pixel(
- colour: &str,
- primaries: &str,
- transfer: &str,
- matrix: &str,
-) -> Option<[u8; 4]> {
- let video = flat_colour_tagged_video(colour, primaries, transfer, matrix)?;
- let thumb = extract_video_thumbnail(&video, OutputFormat::PNG, &test_media_limits())
- .unwrap_or_else(|error| panic!("{primaries}/{transfer}/{matrix} thumbnails: {error:?}"));
- let (width, height, rgba) = decode_rgba(&thumb.bytes);
- assert_eq!((320, 240), (width, height));
- let centre = ((height as usize / 2) * width as usize + width as usize / 2) * 4;
- Some([
- rgba[centre],
- rgba[centre + 1],
- rgba[centre + 2],
- rgba[centre + 3],
- ])
-}
-
-#[test]
-fn a_pq_video_frame_is_tone_mapped_rather_than_read_as_srgb() {
- let Some(sdr) = flat_colour_centre_pixel("0xc0c0c0", "bt709", "bt709", "bt709") else {
- eprintln!("skipping: ffmpeg CLI not available");
- return;
- };
- let hdr = flat_colour_centre_pixel("0xc0c0c0", "bt2020", "smpte2084", "bt2020nc")
- .expect("pq fixture");
- assert!(
- hdr[0] > sdr[0] + 20,
- "a PQ highlight read as plain sRGB would land on the sdr value, got {hdr:?} against {sdr:?}"
- );
- assert_eq!(255, hdr[3], "tone mapped output stays opaque");
-}
-
-#[test]
-fn an_hlg_video_frame_is_tone_mapped_rather_than_read_as_srgb() {
- let Some(sdr) = flat_colour_centre_pixel("0xc0c0c0", "bt709", "bt709", "bt709") else {
- eprintln!("skipping: ffmpeg CLI not available");
- return;
- };
- let hdr = flat_colour_centre_pixel("0xc0c0c0", "bt2020", "arib-std-b67", "bt2020nc")
- .expect("hlg fixture");
- assert!(
- hdr[0] > sdr[0] + 20,
- "an HLG highlight read as plain sRGB would land on the sdr value, got {hdr:?} against {sdr:?}"
- );
- assert_eq!(255, hdr[3], "tone mapped output stays opaque");
-}
-
-#[test]
-fn a_bt2020_sdr_video_frame_is_converted_into_the_bt709_gamut() {
- let Some(wide) = flat_colour_centre_pixel("0x00ff00", "bt2020", "bt709", "bt709") else {
- eprintln!("skipping: ffmpeg CLI not available");
- return;
- };
- let narrow =
- flat_colour_centre_pixel("0x00ff00", "bt709", "bt709", "bt709").expect("bt709 fixture");
- let shift = (0..3)
- .map(|channel| wide[channel].abs_diff(narrow[channel]))
- .max()
- .expect("three channels");
- assert!(
- shift > 8,
- "bt2020 green {wide:?} should not match bt709 green {narrow:?}"
- );
-}
-
-#[test]
-fn video_thumbnail_corrects_display_geometry() {
- let Some(plain) = ffmpeg_gen_mp4(&[
- "-f",
- "lavfi",
- "-i",
- "testsrc=size=320x240:rate=10:duration=1",
- "-pix_fmt",
- "yuv420p",
- "-f",
- "mp4",
- ]) else {
- eprintln!("skipping: ffmpeg CLI not available");
- return;
- };
- let thumb = extract_video_thumbnail(&plain, OutputFormat::PNG, &test_media_limits())
- .expect("plain thumbnail");
- assert_eq!(
- png_dimensions(&thumb.bytes),
- Some((320, 240)),
- "square-pixel video should keep its coded dimensions"
- );
-
- let anamorphic = ffmpeg_gen_mp4(&[
- "-f",
- "lavfi",
- "-i",
- "testsrc=size=1280x720:rate=10:duration=1",
- "-vf",
- "setsar=2/1",
- "-pix_fmt",
- "yuv420p",
- "-f",
- "mp4",
- ])
- .expect("anamorphic fixture");
- let thumb = extract_video_thumbnail(&anamorphic, OutputFormat::PNG, &test_media_limits())
- .expect("anamorphic thumbnail");
- let (w, h) = png_dimensions(&thumb.bytes).expect("anamorphic png dimensions");
- assert_eq!(h, 720, "anamorphic height preserved");
- assert!(
- (i64::from(w) - 2560).abs() <= 2,
- "anamorphic width should expand to the ~2560 display width, got {w}"
- );
-
- let narrow = ffmpeg_gen_mp4(&[
- "-f",
- "lavfi",
- "-i",
- "testsrc=size=1280x720:rate=10:duration=1",
- "-vf",
- "setsar=1/2",
- "-pix_fmt",
- "yuv420p",
- "-f",
- "mp4",
- ])
- .expect("narrow anamorphic fixture");
- let thumb = extract_video_thumbnail(&narrow, OutputFormat::PNG, &test_media_limits())
- .expect("narrow anamorphic thumbnail");
- assert_eq!(
- png_dimensions(&thumb.bytes),
- Some((640, 720)),
- "sub-square pixel video should shrink width to its display size"
- );
-
- let rotated = ffmpeg_gen_rotated_mp4(
- "90",
- &[
- "-f",
- "lavfi",
- "-i",
- "testsrc=size=640x480:rate=10:duration=1",
- "-pix_fmt",
- "yuv420p",
- "-f",
- "mp4",
- ],
- )
- .expect("rotated fixture");
- let thumb = extract_video_thumbnail(&rotated, OutputFormat::PNG, &test_media_limits())
- .expect("rotated thumbnail");
- assert_eq!(
- png_dimensions(&thumb.bytes),
- Some((480, 640)),
- "rotation-metadata video should present in its display (portrait) orientation"
- );
-
- let rotated_counterclockwise = ffmpeg_gen_rotated_mp4(
- "-90",
- &[
- "-f",
- "lavfi",
- "-i",
- "testsrc=size=640x480:rate=10:duration=1",
- "-pix_fmt",
- "yuv420p",
- "-f",
- "mp4",
- ],
- )
- .expect("counterclockwise rotated fixture");
- let thumb = extract_video_thumbnail(
- &rotated_counterclockwise,
- OutputFormat::PNG,
- &test_media_limits(),
- )
- .expect("counterclockwise rotated thumbnail");
- assert_eq!(
- png_dimensions(&thumb.bytes),
- Some((480, 640)),
- "either quarter-turn direction should swap dimensions"
- );
-
- let rotated_anamorphic = ffmpeg_gen_rotated_mp4(
- "90",
- &[
- "-f",
- "lavfi",
- "-i",
- "testsrc=size=320x180:rate=10:duration=1",
- "-vf",
- "setsar=2/1",
- "-pix_fmt",
- "yuv420p",
- "-f",
- "mp4",
- ],
- )
- .expect("rotated anamorphic fixture");
- let thumb =
- extract_video_thumbnail(&rotated_anamorphic, OutputFormat::PNG, &test_media_limits())
- .expect("rotated anamorphic thumbnail");
- assert_eq!(
- png_dimensions(&thumb.bytes),
- Some((180, 640)),
- "SAR correction should happen in coded space before rotation"
- );
-
- let single = ffmpeg_gen_mp4(&[
- "-f",
- "lavfi",
- "-i",
- "testsrc=size=200x150:rate=1:duration=1",
- "-frames:v",
- "1",
- "-pix_fmt",
- "yuv420p",
- "-f",
- "mp4",
- ])
- .expect("single-frame fixture");
- let thumb = extract_video_thumbnail(&single, OutputFormat::PNG, &test_media_limits())
- .expect("single-frame thumbnail");
- assert_eq!(
- png_dimensions(&thumb.bytes),
- Some((200, 150)),
- "single-frame clip should still produce a thumbnail"
- );
-}
-
-#[test]
-fn mirrored_display_matrix_flips_the_video_frame_horizontally() {
- let source_args = [
- "-f",
- "lavfi",
- "-i",
- "testsrc=size=64x48:rate=10:duration=1",
- "-pix_fmt",
- "yuv420p",
- "-f",
- "mp4",
- ];
- let Some(plain) = ffmpeg_gen_mp4(&source_args) else {
- eprintln!("skipping: ffmpeg CLI not available");
- return;
- };
- let mirrored = ffmpeg_mirror_mp4(&plain).expect("mirrored fixture");
- let plain_thumb = extract_video_thumbnail(&plain, OutputFormat::PNG, &test_media_limits())
- .expect("plain thumbnail");
- let mirrored_thumb =
- extract_video_thumbnail(&mirrored, OutputFormat::PNG, &test_media_limits())
- .expect("mirrored thumbnail");
- let (width, height, plain_rgba) = decode_rgba(&plain_thumb.bytes);
- let (mirrored_width, mirrored_height, mirrored_rgba) = decode_rgba(&mirrored_thumb.bytes);
- assert_eq!((64, 48), (width, height));
- assert_eq!((width, height), (mirrored_width, mirrored_height));
- assert_ne!(
- plain_rgba, mirrored_rgba,
- "the mirrored source must not decode to the same pixels"
- );
- let row_stride = width as usize * 4;
- for y in 0..height as usize {
- for x in 0..width as usize {
- let source = y * row_stride + x * 4;
- let mirror = y * row_stride + (width as usize - 1 - x) * 4;
- assert_eq!(
- plain_rgba[source..source + 4],
- mirrored_rgba[mirror..mirror + 4],
- "pixel ({x}, {y}) is not the horizontal mirror of the source"
- );
- }
- }
-}
-
-#[test]
-fn video_metadata_placeholder_and_dimensions_are_display_corrected() {
- let Some(rotated) = ffmpeg_gen_rotated_mp4(
- "90",
- &[
- "-f",
- "lavfi",
- "-i",
- "testsrc=size=640x480:rate=10:duration=1",
- "-pix_fmt",
- "yuv420p",
- "-f",
- "mp4",
- ],
- ) else {
- eprintln!("skipping: ffmpeg CLI not available");
- return;
- };
- let meta = metadata_value(&rotated, "rotated.mp4");
- assert_eq!(
- meta["width"].as_u64(),
- Some(480),
- "stored width is the display (portrait) width"
- );
- assert_eq!(
- meta["height"].as_u64(),
- Some(640),
- "stored height is the display (portrait) height"
- );
- assert!(
- meta["placeholder"].as_str().is_some_and(|s| !s.is_empty()),
- "placeholder should be generated from the display-corrected frame"
- );
-
- let anamorphic = ffmpeg_gen_mp4(&[
- "-f",
- "lavfi",
- "-i",
- "testsrc=size=1280x720:rate=10:duration=1",
- "-vf",
- "setsar=2/1",
- "-pix_fmt",
- "yuv420p",
- "-f",
- "mp4",
- ])
- .expect("anamorphic fixture");
- let meta = metadata_value(&anamorphic, "anamorphic.mp4");
- assert_eq!(
- meta["height"].as_u64(),
- Some(720),
- "stored height preserved"
- );
- let w = meta["width"].as_u64().expect("stored width");
- assert!(
- (w as i64 - 2560).abs() <= 2,
- "stored width expands to the display width, got {w}"
- );
-}
diff --git a/fluxer_media_proxy/src/mime/tests.rs b/fluxer_media_proxy/src/mime/tests.rs
index 1fa3e8004..02ad4f089 100644
--- a/fluxer_media_proxy/src/mime/tests.rs
+++ b/fluxer_media_proxy/src/mime/tests.rs
@@ -1,10 +1,6 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
use super::*;
-use crate::test_fixtures::{
- ADVERSARIAL_TEXT_INPUTS, adversarial_media_bytes, animated_gif_fixture, apng_header,
- minimal_gif,
-};
const WHATWG_JAVASCRIPT_ESSENCES: [&str; 16] = [
"application/ecmascript",
@@ -36,17 +32,6 @@ fn javascript_content_type_matches_every_whatwg_essence() {
}
}
-#[test]
-fn javascript_content_type_ignores_case_whitespace_and_parameters() {
- for content_type in [
- "TEXT/JavaScript",
- " \ttext/javascript ; charset=utf-8",
- "text/javascript;goal=module",
- ] {
- assert!(is_javascript_content_type(content_type), "{content_type:?}");
- }
-}
-
#[test]
fn javascript_content_type_checks_every_comma_separated_member() {
assert!(is_javascript_content_type("image/png, text/javascript"));
@@ -71,380 +56,3 @@ fn javascript_content_type_ends_the_essence_where_browsers_do() {
assert!(is_javascript_content_type(content_type), "{content_type:?}");
}
}
-
-#[test]
-fn javascript_content_type_checks_a_comma_member_that_has_junk() {
- for content_type in [
- "video/mp4, text/javascript x",
- "video/mp4,text/javascript(x)",
- "image/png, \ttext/javascript\tx",
- "text/plain; a=\",\", text/javascript x",
- "text/javascript x, video/mp4",
- ] {
- assert!(is_javascript_content_type(content_type), "{content_type:?}");
- }
-}
-
-#[test]
-fn javascript_content_type_leaves_every_other_type_alone() {
- for content_type in [
- "text/css; charset=utf-8",
- "text/css",
- "application/wasm",
- "text/html",
- "application/xhtml+xml",
- "image/svg+xml",
- "image/png",
- "video/mp2t",
- "video/mp4",
- "application/json",
- "text/plain",
- "application/octet-stream",
- "text/javascript1.6",
- "text/javascriptx",
- "text/javascriptx (x)",
- "text/javascript1.6 x",
- "xtext/javascript",
- "x text/javascript",
- "text /javascript",
- "text/java script",
- "text/javascript\"x",
- "video/mp4, image/png x",
- "",
- " ",
- ",",
- ] {
- assert!(
- !is_javascript_content_type(content_type),
- "{content_type:?}"
- );
- }
-}
-
-#[test]
-fn javascript_content_type_never_panics_on_adversarial_text() {
- for text in ADVERSARIAL_TEXT_INPUTS {
- assert!(!is_javascript_content_type(text), "{text:?}");
- }
-}
-
-fn vp8x_webp(flags: u8, width_minus_one: u32, height_minus_one: u32) -> Vec<u8> {
- let mut webp = vec![0_u8; 30];
- webp[0..4].copy_from_slice(b"RIFF");
- webp[8..12].copy_from_slice(b"WEBP");
- webp[12..16].copy_from_slice(b"VP8X");
- webp[16..20].copy_from_slice(&10_u32.to_le_bytes());
- webp[20] = flags;
- webp[24..27].copy_from_slice(&width_minus_one.to_le_bytes()[..3]);
- webp[27..30].copy_from_slice(&height_minus_one.to_le_bytes()[..3]);
- webp
-}
-
-fn png_chunk(kind: &[u8; 4], payload: &[u8]) -> Vec<u8> {
- let mut chunk = Vec::new();
- chunk.extend_from_slice(
- &u32::try_from(payload.len())
- .expect("test payload fits a PNG chunk")
- .to_be_bytes(),
- );
- chunk.extend_from_slice(kind);
- chunk.extend_from_slice(payload);
- chunk.extend_from_slice(&[0; 4]);
- chunk
-}
-
-#[test]
-fn sniffs_common_image_formats() {
- assert_eq!("image/png", sniff(b"\x89PNG\r\n\x1a\nxxxx").mime);
- assert_eq!("image/jpeg", sniff(b"\xff\xd8\xff").mime);
- assert_eq!("image/gif", sniff(b"GIF89a\x01\x00\x01\x00").mime);
- assert_eq!("image/tiff", sniff(b"II*\0xxxx").mime);
- assert_eq!("image/tiff", sniff(b"MM\0*xxxx").mime);
- assert_eq!("image/bmp", sniff(b"BMxxxx").mime);
-}
-
-#[test]
-fn sniffs_apng_via_actl_chunk() {
- let apng = apng_header(2);
- let info = sniff(&apng);
- assert_eq!("image/apng", info.mime);
- assert!(info.animated);
-}
-
-#[test]
-fn sniffs_animated_webp_via_anim_chunk() {
- let info = sniff(&vp8x_webp(0x02, 0, 0));
- assert_eq!("image/webp", info.mime);
- assert!(info.animated);
-}
-
-#[test]
-fn sniffs_ftyp_boxes_for_heic_avif_mp4_variants() {
- assert_eq!(
- "image/avif",
- sniff(b"\x00\x00\x00\x20ftypavifsome bytes").mime
- );
- assert_eq!(
- "image/avif",
- sniff(b"\x00\x00\x00\x20ftypavissome bytes").mime
- );
- assert!(sniff(b"\x00\x00\x00\x20ftypavissome bytes").animated);
- assert_eq!(
- "image/heif",
- sniff(b"\x00\x00\x00\x20ftypmif1some bytes").mime
- );
- assert_eq!(
- "image/heic",
- sniff(b"\x00\x00\x00\x20ftypheicsome bytes").mime
- );
- assert_eq!(
- "video/mp4",
- sniff(b"\x00\x00\x00\x20ftypiso5some bytes").mime
- );
- assert_eq!(
- "video/mp4",
- sniff(b"\x00\x00\x00\x20ftypM4V some bytes").mime
- );
- assert_eq!(
- "audio/mp4",
- sniff(b"\x00\x00\x00\x20ftypM4A some bytes").mime
- );
- assert_eq!(
- "video/quicktime",
- sniff(b"\x00\x00\x00\x20ftypqt some bytes").mime
- );
-}
-
-#[test]
-fn sniffs_the_literal_heif_ftyp_brand() {
- let heif = b"\x00\x00\x00\x20ftypheifsome bytes";
- assert_eq!("image/heic", sniff(heif).mime);
- assert!(!sniff(heif).animated);
-}
-
-#[test]
-fn scans_every_compatible_brand_of_a_fully_present_ftyp_box() {
- let compatible_brands = 40;
- let box_size = 16 + compatible_brands * 4;
- let mut ftyp = Vec::new();
- ftyp.extend_from_slice(
- &u32::try_from(box_size)
- .expect("test ftyp box size fits u32")
- .to_be_bytes(),
- );
- ftyp.extend_from_slice(b"ftyp");
- ftyp.extend_from_slice(b"isom");
- ftyp.extend_from_slice(&0x0000_0200_u32.to_be_bytes());
- for _ in 0..compatible_brands - 1 {
- ftyp.extend_from_slice(b"isom");
- }
- ftyp.extend_from_slice(b"avif");
- assert_eq!(box_size, ftyp.len());
- assert!(box_size - 4 > 128);
- assert_eq!("image/avif", sniff(&ftyp).mime);
-
- let mut truncated_box = ftyp.clone();
- truncated_box[0..4].copy_from_slice(&u32::MAX.to_be_bytes());
- assert_eq!("video/mp4", sniff(&truncated_box).mime);
-}
-
-#[test]
-fn detect_prefers_m4a_extension_over_generic_mp4_brand() {
- assert_eq!(
- "audio/mp4",
- detect(
- b"\x00\x00\x00\x20ftypisom\x00\x00\x02\x00isomiso2mp41",
- "track.m4a",
- None
- )
- );
-}
-
-#[test]
-fn sniffs_matroska_vs_webm() {
- let mkv = b"\x1a\x45\xdf\xa3\x9f\x42\x86\x81\x01\x42\xf7\x81\x01\x42\xf2\x81\x04\x42\xf3\x81\x08\x42\x82\x88matroska";
- assert_eq!("video/x-matroska", sniff(mkv).mime);
- assert_eq!(
- "video/webm",
- sniff(b"\x1a\x45\xdf\xa3 here is the webm doctype").mime
- );
-}
-
-#[test]
-fn sniffs_audio_variants() {
- assert_eq!("audio/mpeg", sniff(b"ID3\x04\x00\x00").mime);
- assert_eq!("audio/mpeg", sniff(b"\xff\xfb\x90\x00").mime);
- assert_eq!("audio/ogg", sniff(b"OggS\x00\x02").mime);
- assert_eq!("video/ogg", sniff(b"OggS\x00\x02xxxx\x80theora").mime);
- assert_eq!("audio/flac", sniff(b"fLaC\x00\x00").mime);
- assert_eq!("audio/wav", sniff(b"RIFF\x00\x00\x00\x00WAVEdata").mime);
-}
-
-#[test]
-fn extension_mime_covers_common_audio_and_video_containers() {
- assert_eq!(Some("video/ogg"), extension_mime("movie.ogv"));
- assert_eq!(Some("audio/ogg"), extension_mime("voice.opus"));
- assert_eq!(Some("audio/flac"), extension_mime("track.flac"));
- assert_eq!(Some("video/x-matroska"), extension_mime("clip.mkv"));
- assert_eq!(Some("image/tiff"), extension_mime("scan.tiff"));
- assert_eq!(Some("image/bmp"), extension_mime("bitmap.bmp"));
-}
-
-#[test]
-fn sniffs_pdf() {
- assert_eq!("application/pdf", sniff(b"%PDF-1.7\n").mime);
-}
-
-#[test]
-fn mime_sniff_recognizes_bounded_container_headers() {
- let png = apng_header(2);
- let sniffed = sniff(&png);
- assert_eq!("image/apng", sniffed.mime);
- assert!(sniffed.animated);
- assert_eq!(2, sniffed.frames);
- assert_eq!((2, 3), (sniffed.width, sniffed.height));
- assert!(sniffed.has_alpha);
-
- let gif = minimal_gif();
- let sniffed = sniff(&gif);
- assert_eq!("image/gif", sniffed.mime);
- assert!(!sniffed.animated);
- assert_eq!((1, 1), (sniffed.width, sniffed.height));
-
- let animated = animated_gif_fixture();
- let sniffed = sniff(&animated);
- assert_eq!("image/gif", sniffed.mime);
- assert!(sniffed.animated);
- assert_eq!(2, sniffed.frames);
- assert_eq!((32, 32), (sniffed.width, sniffed.height));
-
- let sniffed = sniff(&vp8x_webp(0x12, 1, 2));
- assert_eq!("image/webp", sniffed.mime);
- assert!(sniffed.animated);
- assert!(sniffed.has_alpha);
- assert_eq!((2, 3), (sniffed.width, sniffed.height));
-
- let mut bmff = Vec::new();
- bmff.extend_from_slice(&24_u32.to_be_bytes());
- bmff.extend_from_slice(b"ftyp");
- bmff.extend_from_slice(b"M4A ");
- bmff.extend_from_slice(&0_u32.to_be_bytes());
- bmff.extend_from_slice(b"isom");
- bmff.extend_from_slice(b"M4A ");
- assert_eq!("audio/mp4", sniff(&bmff).mime);
-}
-
-#[test]
-fn mime_sniffing_stays_bounded_on_adversarial_containers() {
- for bytes in adversarial_media_bytes() {
- let sniffed = sniff(&bytes);
- assert!(sniffed.frames >= 1, "zero frames for {} bytes", bytes.len());
- }
-}
-
-#[test]
-fn structural_parsers_reject_the_byte_scan_false_positives() {
- let mut png = b"\x89PNG\r\n\x1a\n".to_vec();
- png.extend_from_slice(&png_chunk(b"IHDR", &[0; 13]));
- png.extend_from_slice(&png_chunk(b"IDAT", b"acTL rides inside the pixel data"));
- let info = sniff(&png);
- assert_eq!("image/png", info.mime);
- assert!(!info.animated);
-
- let mut gif = minimal_gif();
- gif.extend_from_slice(b"\x21\xffNETSCAPE2.0");
- let info = sniff(&gif);
- assert_eq!("image/gif", info.mime);
- assert!(!info.animated);
-
- let info = sniff(b"RIFF\x00\x00\x00\x00WEBPVP8XANIMxxxx");
- assert_eq!("image/webp", info.mime);
- assert!(!info.animated);
- assert!(!info.has_alpha);
-}
-
-#[test]
-fn detect_falls_back_to_the_extension_then_the_declared_header() {
- assert_eq!("audio/mp4", detect(b"", "clip.m4a", None));
- assert_eq!(
- "IMAGE/PNG",
- detect(b"", "unknown.bin", Some("IMAGE/PNG; charset=binary"))
- );
- assert_eq!("application/octet-stream", detect(b"", "unknown.bin", None));
- assert_eq!(
- "image/png",
- detect(b"\x89PNG\r\n\x1a\nxxxx", "audio.m4a", Some("image/gif"))
- );
-}
-
-#[test]
-fn sniffs_adts_aac_and_aiff_containers() {
- let mut adts = vec![0xff, 0xf1, 0x50, 0x80, 0x01, 0xa0, 0xfc];
- adts.resize(13, 0);
- assert_eq!("audio/aac", sniff(&adts).mime);
- assert_eq!("audio/aiff", sniff(b"FORM\x00\x00\x00\x12AIFF").mime);
- assert_eq!("audio/aiff", sniff(b"FORM\x00\x00\x00\x12AIFC").mime);
- assert_eq!(
- "application/octet-stream",
- sniff(b"FORM\x00\x00\x00\x12WAVE").mime
- );
-}
-
-#[test]
-fn content_type_normalization_and_categories_ignore_case_and_reject_control_bytes() {
- assert_eq!(Some("image/png"), normalize(Some("image/png; charset=x")));
- assert_eq!(Some("image/png"), normalize(Some(" \timage/png\t ")));
- assert_eq!(None, normalize(Some("image/p\rng")));
- assert_eq!(None, normalize(Some(" ")));
- assert_eq!(None, normalize(None));
-
- assert_eq!(Some(Category::Image), category("IMAGE/PNG"));
- assert_eq!(Some(Category::Video), category("Video/MP4"));
- assert_eq!(Some(Category::Audio), category("AUDIO/wav"));
- assert_eq!(None, category("text/css"));
- assert_eq!(None, category("image"));
-}
-
-#[test]
-fn registry_lookups_canonicalize_extensions() {
- assert_eq!(Some("image/jpeg"), extension_mime("photo.JPG"));
- assert_eq!(Some("text/css; charset=utf-8"), extension_mime("app.css"));
- assert_eq!(None, extension_mime("manual.PDF"));
- assert_eq!(None, extension_mime("archive.zip"));
- assert_eq!(None, extension_mime("noextension"));
-}
-
-#[test]
-fn supported_media_mimes_gate_metadata_on_the_frozen_allow_list() {
- assert!(is_supported_media_mime("image/heif"));
- assert!(is_supported_media_mime("image/heic"));
- assert!(is_supported_media_mime("video/mp4; codecs=avc1"));
- assert!(!is_supported_media_mime("image/avif-sequence"));
- assert!(!is_supported_media_mime("IMAGE/PNG"));
- assert!(!is_supported_media_mime("application/pdf"));
- assert!(!is_supported_media_mime(""));
-}
-
-#[test]
-fn every_iso_bmff_brand_matches_the_old_era_table() {
- for (brand, expected) in [
- (&b"heic"[..], "image/heic"),
- (b"heix", "image/heic"),
- (b"heif", "image/heic"),
- (b"heim", "image/heic"),
- (b"heis", "image/heic"),
- (b"hevc", "image/heic"),
- (b"hevx", "image/heic"),
- (b"hevm", "image/heic"),
- (b"hevs", "image/heic"),
- (b"mif1", "image/heif"),
- (b"msf1", "image/heif"),
- ] {
- let mut bytes = b"\x00\x00\x00\x20ftyp".to_vec();
- bytes.extend_from_slice(brand);
- bytes.extend_from_slice(b"some bytes");
- let info = sniff(&bytes);
- assert_eq!(expected, info.mime, "brand {brand:?}");
- assert!(!info.animated, "brand {brand:?} must not be animated");
- }
-}
diff --git a/fluxer_media_proxy/src/nsfw.rs b/fluxer_media_proxy/src/nsfw.rs
index 0dc9ae581..6e839be9e 100644
--- a/fluxer_media_proxy/src/nsfw.rs
+++ b/fluxer_media_proxy/src/nsfw.rs
@@ -368,158 +368,3 @@ pub fn verdict_from_frame_probabilities(
fn number_as_f32(value: &Value) -> Option<f32> {
value.as_f64().map(|v| v as f32)
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use crate::metrics::Metrics;
-
- fn threshold() -> NSFWThreshold {
- NSFWThreshold::new(0.85).expect("0.85 is a valid threshold")
- }
-
- #[test]
- fn parse_batch_probabilities_reads_every_frame() {
- let parsed = parse_batch_probabilities(
- br#"{"predictions":[{"nsfw_probability":0.1},{"nsfw_probability":0.7},{"nsfw_probability":0.3}]}"#,
- )
- .unwrap();
- assert_eq!(3, parsed.len());
- assert!((parsed[1] - 0.7).abs() < 0.001);
- assert!(
- parse_batch_probabilities(br#"{"predictions":[]}"#)
- .unwrap()
- .is_empty()
- );
- assert_eq!(
- Err(NSFWError::InvalidResponse),
- parse_batch_probabilities(br#"{}"#)
- );
- assert_eq!(
- Err(NSFWError::InvalidResponse),
- parse_batch_probabilities(b"not-json")
- );
- }
-
- #[test]
- fn single_high_frame_does_not_flag_a_multi_frame_scan() {
- let verdict = verdict_from_frame_probabilities(
- &[0.02, 0.99, 0.03],
- NSFWThreshold::new(0.95).unwrap(),
- );
- assert!(!verdict.is_nsfw);
- assert!((verdict.probability - 0.99).abs() < 0.001);
- }
-
- #[test]
- fn two_high_frames_flag_a_multi_frame_scan() {
- assert!(
- verdict_from_frame_probabilities(
- &[0.02, 0.99, 0.97],
- NSFWThreshold::new(0.95).unwrap()
- )
- .is_nsfw
- );
- }
-
- #[test]
- fn a_lone_frame_still_flags_on_its_own() {
- assert!(
- verdict_from_frame_probabilities(&[0.99], NSFWThreshold::new(0.95).unwrap()).is_nsfw
- );
- assert!(
- !verdict_from_frame_probabilities(&[0.94], NSFWThreshold::new(0.95).unwrap()).is_nsfw
- );
- }
-
- #[test]
- fn an_empty_scan_never_flags() {
- let verdict = verdict_from_frame_probabilities(&[], NSFWThreshold::new(0.95).unwrap());
- assert!(!verdict.is_nsfw);
- assert!((verdict.probability - 0.0).abs() < 0.001);
- }
-
- #[test]
- fn frames_at_the_threshold_count_as_over() {
- assert!(
- verdict_from_frame_probabilities(&[0.95, 0.95], NSFWThreshold::new(0.95).unwrap())
- .is_nsfw
- );
- }
-
- #[test]
- fn disabled_when_endpoint_empty() {
- let client = NSFWClient::new("", 0.85, Arc::new(NSFWMetrics::default())).unwrap();
- assert_eq!(NSFWPolicy::Disabled, client.policy());
- assert_eq!(None, client.policy().scan_threshold(true));
- }
-
- #[test]
- fn parse_probability_accepts_known_shapes() {
- assert!((parse_probability(br#"{"nsfw_probability":0.42}"#).unwrap() - 0.42).abs() < 0.001);
- assert!((parse_probability(br#"{"score":0.99}"#).unwrap() - 0.99).abs() < 0.001);
- assert!((parse_probability(br#"{"probability":1}"#).unwrap() - 1.0).abs() < 0.001);
- assert!((parse_probability(br#"{"nsfw":0}"#).unwrap() - 0.0).abs() < 0.001);
- assert_eq!(Err(NSFWError::InvalidResponse), parse_probability(br#"{}"#));
- assert_eq!(
- Err(NSFWError::InvalidResponse),
- parse_probability(b"not-json")
- );
- }
-
- #[test]
- fn probability_clamped_to_unit_interval() {
- assert!((parse_probability(br#"{"score":2.5}"#).unwrap() - 1.0).abs() < 0.001);
- assert!((parse_probability(br#"{"score":-0.3}"#).unwrap() - 0.0).abs() < 0.001);
- }
-
- #[test]
- fn a_threshold_outside_the_unit_interval_is_rejected() {
- assert_eq!(Err(InvalidNSFWThreshold), NSFWThreshold::new(1.5));
- assert_eq!(Err(InvalidNSFWThreshold), NSFWThreshold::new(-0.1));
- assert_eq!(Err(InvalidNSFWThreshold), NSFWThreshold::new(f32::NAN));
- assert!(threshold().classifies_as_nsfw(0.85));
- assert!(!threshold().classifies_as_nsfw(0.849));
- }
-
- #[test]
- fn a_scan_request_bounds_its_frames() {
- assert_eq!(
- InvalidNSFWScanRequest::Empty,
- NSFWScanRequest::new(threshold(), Vec::new()).unwrap_err()
- );
- assert_eq!(
- InvalidNSFWScanRequest::EmptyFrame { index: 1 },
- NSFWScanRequest::new(threshold(), vec![vec![1], Vec::new()]).unwrap_err()
- );
- assert_eq!(
- InvalidNSFWScanRequest::FrameTooLarge {
- index: 0,
- bytes: NSFW_MAX_FRAME_BYTES + 1,
- },
- NSFWScanRequest::new(threshold(), vec![vec![1; NSFW_MAX_FRAME_BYTES + 1]]).unwrap_err()
- );
- assert!(NSFWScanRequest::new(threshold(), vec![vec![1]; NSFW_MAX_FRAMES]).is_ok());
- }
-
- #[tokio::test]
- async fn a_four_frame_request_is_rejected_before_any_http_call() {
- let metrics = Metrics::new();
- let client = NSFWClient::new("http://127.0.0.1:9/", 0.85, metrics.nsfw()).unwrap();
- assert_eq!(
- InvalidNSFWScanRequest::TooManyFrames { count: 4 },
- NSFWScanRequest::new(threshold(), vec![vec![1]; 4]).unwrap_err()
- );
- let rendered = metrics.render();
- assert!(rendered.contains("fluxer_media_proxy_nsfw_calls_failed_total 0"));
-
- let reachable = NSFWScanRequest::new(threshold(), vec![vec![1]]).unwrap();
- assert_eq!(
- Err(NSFWError::Unavailable),
- client.check_buffers(reachable).await
- );
- let rendered = metrics.render();
- assert!(rendered.contains("fluxer_media_proxy_nsfw_calls_failed_total 1"));
- assert!(rendered.contains("fluxer_media_proxy_nsfw_calls_ok_total 0"));
- }
-}
diff --git a/fluxer_media_proxy/src/output_format.rs b/fluxer_media_proxy/src/output_format.rs
index 3ce685d74..ae86379ab 100644
--- a/fluxer_media_proxy/src/output_format.rs
+++ b/fluxer_media_proxy/src/output_format.rs
@@ -102,44 +102,3 @@ pub fn select_url_variant(input: Input) -> OutputSelection {
},
}
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn unsupported_url_extension_coerces_to_webp() {
- let r = select_url_variant(Input {
- kind: AssetKind::Avatar,
- original: AssetExtension::Avif,
- requested_size: Some(128),
- manual_format_override: None,
- });
- assert_eq!(OutputFormat::WebP, r.format);
- assert_eq!("url-coerced", r.reason);
- }
-
- #[test]
- fn svg_url_extension_coerces_to_webp() {
- let r = select_url_variant(Input {
- kind: AssetKind::Avatar,
- original: AssetExtension::Svg,
- requested_size: Some(128),
- manual_format_override: None,
- });
- assert_eq!(OutputFormat::WebP, r.format);
- assert_eq!("url-coerced", r.reason);
- }
-
- #[test]
- fn manual_unsupported_query_format_coerces_to_webp() {
- let r = select_url_variant(Input {
- kind: AssetKind::Avatar,
- original: AssetExtension::Jpeg,
- requested_size: Some(256),
- manual_format_override: Some(AssetExtension::Svg),
- });
- assert_eq!(OutputFormat::WebP, r.format);
- assert_eq!("url-coerced", r.reason);
- }
-}
diff --git a/fluxer_media_proxy/src/test_fixtures.rs b/fluxer_media_proxy/src/test_fixtures.rs
new file mode 100644
index 000000000..78b4dfd2f
--- /dev/null
+++ b/fluxer_media_proxy/src/test_fixtures.rs
@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::{media_process::native_runtime::ensure_vips_init, native};
+use libc::{c_int, c_void, size_t};
+use std::{ffi::CString, ptr};
+
+pub const ADVERSARIAL_TEXT_INPUTS: &[&str] = &[
+ "",
+ " ",
+ "%",
+ "%0",
+ "%00",
+ "%2F",
+ "%2f",
+ "%5C",
+ "%FF",
+ "%C3",
+ "%C3%A9",
+ "%%%%",
+ "%20%2e%2e%2f",
+ "a_deadbeef",
+ "A_DEADBEEF",
+ "deadbeef",
+ "deadbee",
+ "deadbeef0",
+ "0123456789",
+ "a_",
+ "\"quoted\"",
+ "photo name.png",
+ "r\u{e9}sum\u{e9}.png",
+ "token=",
+ "token=abc&token=def",
+ "\u{7f}",
+ "~!@#$^&*()_+",
+];
+
+pub fn synthetic_png(width: u32, height: u32) -> Vec<u8> {
+ ensure_vips_init().unwrap();
+ let mut pixels = vec![0u8; width as usize * height as usize * 4];
+ for y in 0..height {
+ for x in 0..width {
+ let i = (y as usize * width as usize + x as usize) * 4;
+ pixels[i] = (x * 255 / width.max(1)) as u8;
+ pixels[i + 1] = (y * 255 / height.max(1)) as u8;
+ pixels[i + 2] = 120;
+ pixels[i + 3] = 255;
+ }
+ }
+ let image = unsafe {
+ native::fluxer_vips_image_new_from_memory_copy(
+ pixels.as_ptr().cast(),
+ pixels.len(),
+ width as c_int,
+ height as c_int,
+ 4,
+ native::fluxer_vips_format_uchar,
+ )
+ };
+ let image = unsafe { native::VipsImageHandle::from_raw_owned(image) }.unwrap();
+ let suffix = CString::new(".png[strip]").unwrap();
+ let mut out_ptr: *mut c_void = ptr::null_mut();
+ let mut out_size: size_t = 0;
+ let rc = unsafe {
+ native::fluxer_vips_image_write_to_buffer(
+ image.as_ptr(),
+ suffix.as_ptr(),
+ &mut out_ptr,
+ &mut out_size,
+ )
+ };
+ assert_eq!(0, rc);
+ unsafe { native::buffer::NativeBuffer::from_vips_owned(out_ptr, out_size) }
+ .unwrap()
+ .try_to_vec()
+ .unwrap()
+}
diff --git a/fluxer_media_proxy/src/test_fixtures/adversarial.rs b/fluxer_media_proxy/src/test_fixtures/adversarial.rs
deleted file mode 100644
index ba1cba47f..000000000
--- a/fluxer_media_proxy/src/test_fixtures/adversarial.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use super::images::{apng_header, minimal_gif};
-
-pub fn adversarial_media_bytes() -> Vec<Vec<u8>> {
- let mut truncated_apng = apng_header(2);
- truncated_apng.truncate(20);
-
- let mut oversized_bmff = Vec::new();
- oversized_bmff.extend_from_slice(&u32::MAX.to_be_bytes());
- oversized_bmff.extend_from_slice(b"ftyp");
- oversized_bmff.extend_from_slice(b"isom");
-
- let mut webp_without_payload = vec![0_u8; 20];
- webp_without_payload[0..4].copy_from_slice(b"RIFF");
- webp_without_payload[4..8].copy_from_slice(&u32::MAX.to_le_bytes());
- webp_without_payload[8..12].copy_from_slice(b"WEBP");
- webp_without_payload[12..16].copy_from_slice(b"VP8X");
- webp_without_payload[16..20].copy_from_slice(&u32::MAX.to_le_bytes());
-
- vec![
- Vec::new(),
- vec![0x00],
- vec![0x00; 1024],
- vec![0xff; 1024],
- b"GIF".to_vec(),
- b"GIF89a".to_vec(),
- b"GIF89a\x01\x00".to_vec(),
- minimal_gif(),
- b"\x89PNG\r\n\x1a\n".to_vec(),
- apng_header(0),
- apng_header(u32::MAX),
- truncated_apng,
- b"RIFF".to_vec(),
- webp_without_payload,
- oversized_bmff,
- b"ftypM4A ".to_vec(),
- b"\xff\xd8\xff\xe0".to_vec(),
- ]
-}
-
-pub const ADVERSARIAL_RANGE_HEADERS: &[&str] = &[
- "",
- " ",
- "bytes",
- "bytes=",
- "bytes=-",
- "bytes=--1",
- "bytes=0-",
- "bytes=-0",
- "bytes=0-0",
- "bytes=0-1",
- "bytes=1-0",
- "bytes=18446744073709551615-18446744073709551615",
- "bytes=-18446744073709551615",
- "bytes=18446744073709551616-",
- "bytes=1-2,3-4",
- "bytes = 0-1",
- "BYTES=0-1",
- "items=0-1",
- "bytes 0-0/0",
- "bytes 0-1/1",
- "bytes 1-0/2",
- "bytes 0-1/*",
- "bytes */2",
- "bytes 0-1/18446744073709551616",
- "bytes\t0-1/2",
- "bytes 0-1/2 ",
-];
-
-pub const ADVERSARIAL_TEXT_INPUTS: &[&str] = &[
- "",
- " ",
- "%",
- "%0",
- "%00",
- "%2F",
- "%2f",
- "%5C",
- "%FF",
- "%C3",
- "%C3%A9",
- "%%%%",
- "%20%2e%2e%2f",
- "a_deadbeef",
- "A_DEADBEEF",
- "deadbeef",
- "deadbee",
- "deadbeef0",
- "0123456789",
- "a_",
- "\"quoted\"",
- "photo name.png",
- "r\u{e9}sum\u{e9}.png",
- "token=",
- "token=abc&token=def",
- "\u{7f}",
- "~!@#$^&*()_+",
-];
diff --git a/fluxer_media_proxy/src/test_fixtures/animated_webp_1024_17_frames.webp b/fluxer_media_proxy/src/test_fixtures/animated_webp_1024_17_frames.webp
deleted file mode 100644
index d3fab9198..000000000
Binary files a/fluxer_media_proxy/src/test_fixtures/animated_webp_1024_17_frames.webp and /dev/null differ
diff --git a/fluxer_media_proxy/src/test_fixtures/captured_log.rs b/fluxer_media_proxy/src/test_fixtures/captured_log.rs
deleted file mode 100644
index 9b14070d9..000000000
--- a/fluxer_media_proxy/src/test_fixtures/captured_log.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use std::sync::{Arc, Mutex};
-use tracing_subscriber::fmt::MakeWriter;
-
-#[derive(Clone, Default)]
-pub(crate) struct CapturedLog(Arc<Mutex<Vec<u8>>>);
-
-impl CapturedLog {
- pub(crate) fn text(&self) -> String {
- String::from_utf8(self.0.lock().expect("captured log is not poisoned").clone())
- .expect("captured log is utf-8")
- }
-}
-
-impl std::io::Write for CapturedLog {
- fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
- self.0
- .lock()
- .expect("captured log is not poisoned")
- .extend_from_slice(buf);
- Ok(buf.len())
- }
-
- fn flush(&mut self) -> std::io::Result<()> {
- Ok(())
- }
-}
-
-impl<'a> MakeWriter<'a> for CapturedLog {
- type Writer = Self;
-
- fn make_writer(&'a self) -> Self::Writer {
- self.clone()
- }
-}
diff --git a/fluxer_media_proxy/src/test_fixtures/ffmpeg_cli.rs b/fluxer_media_proxy/src/test_fixtures/ffmpeg_cli.rs
deleted file mode 100644
index a0c83d9a9..000000000
--- a/fluxer_media_proxy/src/test_fixtures/ffmpeg_cli.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-pub const REQUIRE_MEDIA_FIXTURES_ENV: &str = "FLUXER_REQUIRE_MEDIA_FIXTURES";
-
-pub fn media_fixtures_are_required() -> bool {
- std::env::var_os(REQUIRE_MEDIA_FIXTURES_ENV).is_some_and(|value| !value.is_empty())
-}
-
-fn ffmpeg_fixture(description: &str, produced: Option<Vec<u8>>) -> Option<Vec<u8>> {
- assert!(
- produced.is_some() || !media_fixtures_are_required(),
- "{REQUIRE_MEDIA_FIXTURES_ENV} is set but the ffmpeg CLI could not produce {description}"
- );
- produced
-}
-
-pub fn ffmpeg_gen_media(file_name: &str, args: &[&str]) -> Option<Vec<u8>> {
- ffmpeg_fixture(file_name, run_ffmpeg_gen_media(file_name, args))
-}
-
-fn run_ffmpeg_gen_media(file_name: &str, args: &[&str]) -> Option<Vec<u8>> {
- let dir = tempfile::tempdir().ok()?;
- let out = dir.path().join(file_name);
- let status = std::process::Command::new("ffmpeg")
- .args(["-nostdin", "-loglevel", "error", "-y"])
- .args(args)
- .arg(out.to_str()?)
- .status()
- .ok()?;
- if !status.success() {
- return None;
- }
- std::fs::read(&out).ok()
-}
-
-pub fn ffmpeg_gen_mp4(args: &[&str]) -> Option<Vec<u8>> {
- ffmpeg_gen_media("fixture.mp4", args)
-}
-
-pub fn ffmpeg_gen_rotated_mp4(display_rotation: &str, source_args: &[&str]) -> Option<Vec<u8>> {
- ffmpeg_fixture(
- "rotated.mp4",
- run_ffmpeg_gen_rotated_mp4(display_rotation, source_args),
- )
-}
-
-fn run_ffmpeg_gen_rotated_mp4(display_rotation: &str, source_args: &[&str]) -> Option<Vec<u8>> {
- let dir = tempfile::tempdir().ok()?;
- let source = dir.path().join("source.mp4");
- let out = dir.path().join("rotated.mp4");
- let source_status = std::process::Command::new("ffmpeg")
- .args(["-nostdin", "-loglevel", "error", "-y"])
- .args(source_args)
- .arg(source.to_str()?)
- .status()
- .ok()?;
- if !source_status.success() {
- return None;
- }
- let rotate_status = std::process::Command::new("ffmpeg")
- .args(["-nostdin", "-loglevel", "error", "-y", "-noautorotate"])
- .args(["-display_rotation", display_rotation])
- .args(["-i", source.to_str()?])
- .args(["-c", "copy", "-f", "mp4"])
- .arg(out.to_str()?)
- .status()
- .ok()?;
- if !rotate_status.success() {
- return None;
- }
- std::fs::read(&out).ok()
-}
-
-pub fn ffmpeg_mirror_mp4(source_mp4: &[u8]) -> Option<Vec<u8>> {
- ffmpeg_fixture("mirrored.mp4", run_ffmpeg_mirror_mp4(source_mp4))
-}
-
-fn run_ffmpeg_mirror_mp4(source_mp4: &[u8]) -> Option<Vec<u8>> {
- let dir = tempfile::tempdir().ok()?;
- let source = dir.path().join("source.mp4");
- let out = dir.path().join("mirrored.mp4");
- std::fs::write(&source, source_mp4).ok()?;
- let mirror_status = std::process::Command::new("ffmpeg")
- .args(["-nostdin", "-loglevel", "error", "-y", "-noautorotate"])
- .arg("-display_hflip")
- .args(["-i", source.to_str()?])
- .args(["-c", "copy", "-f", "mp4"])
- .arg(out.to_str()?)
- .status()
- .ok()?;
- if !mirror_status.success() {
- return None;
- }
- std::fs::read(&out).ok()
-}
diff --git a/fluxer_media_proxy/src/test_fixtures/images.rs b/fluxer_media_proxy/src/test_fixtures/images.rs
deleted file mode 100644
index 07cf8b175..000000000
--- a/fluxer_media_proxy/src/test_fixtures/images.rs
+++ /dev/null
@@ -1,326 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use crate::{media_process::native_runtime::ensure_vips_init, native};
-use base64::Engine as _;
-use libc::{c_int, c_void, size_t};
-use std::{ffi::CString, ptr};
-
-pub fn minimal_gif() -> Vec<u8> {
- vec![
- 0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x01, 0x00, 0x01, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0xff, 0xff, 0xff, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x02,
- 0x02, 0x44, 0x01, 0x00, 0x3b,
- ]
-}
-
-pub fn apng_header(frames: u32) -> Vec<u8> {
- let mut data = Vec::new();
- data.extend_from_slice(b"\x89PNG\r\n\x1a\n");
- data.extend_from_slice(&13_u32.to_be_bytes());
- data.extend_from_slice(b"IHDR");
- data.extend_from_slice(&2_u32.to_be_bytes());
- data.extend_from_slice(&3_u32.to_be_bytes());
- data.extend_from_slice(&[8, 6, 0, 0, 0]);
- data.extend_from_slice(&[0; 4]);
- data.extend_from_slice(&8_u32.to_be_bytes());
- data.extend_from_slice(b"acTL");
- data.extend_from_slice(&frames.to_be_bytes());
- data.extend_from_slice(&0_u32.to_be_bytes());
- data.extend_from_slice(&[0; 4]);
- data
-}
-
-pub const JXL_4100_LOSSY_ALPHA: &[u8] = include_bytes!("jxl_4100_lossy_alpha.jxl");
-pub const JXL_64_LOSSY_ALPHA: &[u8] = include_bytes!("jxl_64_lossy_alpha.jxl");
-pub const JXL_7000X4000_LOSSY_RGB: &[u8] = include_bytes!("jxl_7000x4000_lossy_rgb.jxl");
-pub const JXL_4100_LOSSLESS_RGB16: &[u8] = include_bytes!("jxl_4100_lossless_rgb16.jxl");
-pub const JXL_4100_LOSSY_RGB_DEPTH: &[u8] = include_bytes!("jxl_4100_lossy_rgb_depth.jxl");
-pub const ANIMATED_WEBP_1024_17_FRAMES: &[u8] = include_bytes!("animated_webp_1024_17_frames.webp");
-pub const JPEG_ROTATED_MISMATCHED_SCAN: &[u8] = include_bytes!("jpeg_rotated_mismatched_scan.jpg");
-
-pub fn synthetic_png(width: u32, height: u32) -> Vec<u8> {
- ensure_vips_init().unwrap();
- let mut pixels = vec![0u8; width as usize * height as usize * 4];
- for y in 0..height {
- for x in 0..width {
- let i = (y as usize * width as usize + x as usize) * 4;
- pixels[i] = (x * 255 / width.max(1)) as u8;
- pixels[i + 1] = (y * 255 / height.max(1)) as u8;
- pixels[i + 2] = 120;
- pixels[i + 3] = 255;
- }
- }
- let image = unsafe {
- native::fluxer_vips_image_new_from_memory_copy(
- pixels.as_ptr().cast(),
- pixels.len(),
- width as c_int,
- height as c_int,
- 4,
- native::fluxer_vips_format_uchar,
- )
- };
- let image = unsafe { native::VipsImageHandle::from_raw_owned(image) }.unwrap();
- let suffix = CString::new(".png[strip]").unwrap();
- let mut out_ptr: *mut c_void = ptr::null_mut();
- let mut out_size: size_t = 0;
- let rc = unsafe {
- native::fluxer_vips_image_write_to_buffer(
- image.as_ptr(),
- suffix.as_ptr(),
- &mut out_ptr,
- &mut out_size,
- )
- };
- assert_eq!(0, rc);
- unsafe { native::buffer::NativeBuffer::from_vips_owned(out_ptr, out_size) }
- .unwrap()
- .try_to_vec()
- .unwrap()
-}
-
-pub fn synthetic_bmp(width: u32, height: u32) -> Vec<u8> {
- assert!(width > 0 && height > 0);
- let row_bytes = (width as usize * 3).next_multiple_of(4);
- let pixel_bytes = row_bytes * height as usize;
- let file_bytes = 54 + pixel_bytes;
- let mut bytes = Vec::with_capacity(file_bytes);
- bytes.extend_from_slice(b"BM");
- bytes.extend_from_slice(&(file_bytes as u32).to_le_bytes());
- bytes.extend_from_slice(&0u16.to_le_bytes());
- bytes.extend_from_slice(&0u16.to_le_bytes());
- bytes.extend_from_slice(&54u32.to_le_bytes());
- bytes.extend_from_slice(&40u32.to_le_bytes());
- bytes.extend_from_slice(&(width as i32).to_le_bytes());
- bytes.extend_from_slice(&(height as i32).to_le_bytes());
- bytes.extend_from_slice(&1u16.to_le_bytes());
- bytes.extend_from_slice(&24u16.to_le_bytes());
- bytes.extend_from_slice(&0u32.to_le_bytes());
- bytes.extend_from_slice(&(pixel_bytes as u32).to_le_bytes());
- bytes.extend_from_slice(&2835i32.to_le_bytes());
- bytes.extend_from_slice(&2835i32.to_le_bytes());
- bytes.extend_from_slice(&0u32.to_le_bytes());
- bytes.extend_from_slice(&0u32.to_le_bytes());
- for y in (0..height).rev() {
- let mut row = Vec::with_capacity(row_bytes);
- for x in 0..width {
- row.push(120);
- row.push((y * 255 / height) as u8);
- row.push((x * 255 / width) as u8);
- }
- row.resize(row_bytes, 0);
- bytes.extend_from_slice(&row);
- }
- bytes
-}
-
-pub fn animated_gif_fixture() -> Vec<u8> {
- base64::engine::general_purpose::STANDARD
- .decode("R0lGODlhIAAgAPEAAAAAAP8AAP///wAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQJFAAAACwAAAAAIAAgAAACPYyPGcDtD5Q8sLY5rcVSV654EJiID4mYDkqpDGu4LyxHtAwv+O3mtb9j1YbEovGITCqXzKbzCY1Kp9QqsQAAIfkECRQAAAAsAAAAACAAIACDAAAAAAD/AAD/AAD/AAD/AAD/AAD/AAD/AAD/AAD/////AAAAAAAAAAAAAAAAAAAABFsQyEmrvTjrzbv/YCiOZGmeaKqubOu+MBUIA1EQgxCYBpH8wATBQDoEj7+DyIBsEj8BX/NIACGmTdAAiwRJuUBQARz0ksOf7TlhXbOhX24VxCQ/QUauctRrDiURADs=")
- .unwrap()
-}
-
-pub fn animated_gif_frames(frames: usize, delay_cs: u16) -> Vec<u8> {
- let mut gif = Vec::new();
- gif.extend_from_slice(b"GIF89a");
- gif.extend_from_slice(&16u16.to_le_bytes());
- gif.extend_from_slice(&16u16.to_le_bytes());
- gif.extend_from_slice(&[0x80, 0x00, 0x00]);
- gif.extend_from_slice(&[0x00, 0x00, 0x00, 0xff, 0xff, 0xff]);
- gif.extend_from_slice(b"\x21\xff\x0bNETSCAPE2.0");
- gif.extend_from_slice(&[0x03, 0x01, 0x00, 0x00, 0x00]);
- for index in 0..frames {
- gif.extend_from_slice(&[0x21, 0xf9, 0x04, 0x00]);
- gif.extend_from_slice(&delay_cs.to_le_bytes());
- gif.extend_from_slice(&[0x00, 0x00]);
- gif.extend_from_slice(&[0x2c, 0x00, 0x00, 0x00, 0x00]);
- gif.extend_from_slice(&1u16.to_le_bytes());
- gif.extend_from_slice(&1u16.to_le_bytes());
- gif.extend_from_slice(&[0x00, 0x02, 0x02]);
- gif.extend_from_slice(if index % 2 == 0 {
- &[0x44, 0x01]
- } else {
- &[0x4c, 0x01]
- });
- gif.push(0x00);
- }
- gif.push(0x3b);
- gif
-}
-
-pub fn read_u24_le(bytes: &[u8]) -> Option<u32> {
- (bytes.len() >= 3)
- .then(|| bytes[0] as u32 | ((bytes[1] as u32) << 8) | ((bytes[2] as u32) << 16))
-}
-
-pub fn webp_chunk_payloads<'a>(bytes: &'a [u8], fourcc: &[u8; 4]) -> Vec<&'a [u8]> {
- if bytes.len() < 12 || &bytes[0..4] != b"RIFF" || &bytes[8..12] != b"WEBP" {
- return Vec::new();
- }
- let mut chunks = Vec::new();
- let mut offset = 12usize;
- while offset + 8 <= bytes.len() {
- let chunk_size = u32::from_le_bytes([
- bytes[offset + 4],
- bytes[offset + 5],
- bytes[offset + 6],
- bytes[offset + 7],
- ]) as usize;
- let payload_start = offset + 8;
- let Some(payload_end) = payload_start.checked_add(chunk_size) else {
- break;
- };
- if payload_end > bytes.len() {
- break;
- }
- if &bytes[offset..offset + 4] == fourcc {
- chunks.push(&bytes[payload_start..payload_end]);
- }
- offset = payload_end + (chunk_size & 1);
- }
- chunks
-}
-
-pub fn webp_canvas_size(bytes: &[u8]) -> Option<(u32, u32, u8)> {
- let vp8x = webp_chunk_payloads(bytes, b"VP8X").into_iter().next()?;
- if vp8x.len() < 10 {
- return None;
- }
- let width = read_u24_le(&vp8x[4..7])? + 1;
- let height = read_u24_le(&vp8x[7..10])? + 1;
- Some((width, height, vp8x[0]))
-}
-
-pub fn first_webp_anim_frame_size(bytes: &[u8]) -> Option<(u32, u32)> {
- let anmf = webp_chunk_payloads(bytes, b"ANMF").into_iter().next()?;
- if anmf.len() < 16 {
- return None;
- }
- let width = read_u24_le(&anmf[6..9])? + 1;
- let height = read_u24_le(&anmf[9..12])? + 1;
- Some((width, height))
-}
-
-pub fn webp_animation_loop_count(bytes: &[u8]) -> Option<u16> {
- let anim = webp_chunk_payloads(bytes, b"ANIM").into_iter().next()?;
- (anim.len() >= 6).then(|| u16::from_le_bytes([anim[4], anim[5]]))
-}
-
-pub fn webp_with_metadata_chunk(bytes: &[u8], fourcc: &[u8; 4], flag: u8) -> Option<Vec<u8>> {
- if bytes.len() < 20 || &bytes[0..4] != b"RIFF" || &bytes[8..12] != b"WEBP" {
- return None;
- }
- if &bytes[12..16] != b"VP8X" {
- return None;
- }
- let vp8x_size = u32::from_le_bytes([bytes[16], bytes[17], bytes[18], bytes[19]]) as usize;
- let vp8x_end = 20usize.checked_add(vp8x_size + (vp8x_size & 1))?;
- if vp8x_end > bytes.len() {
- return None;
- }
- let payload: [u8; 4] = [0x00, 0x01, 0x02, 0x03];
- let mut out = Vec::with_capacity(bytes.len() + 12);
- out.extend_from_slice(&bytes[..vp8x_end]);
- out[20] |= flag;
- out.extend_from_slice(fourcc);
- out.extend_from_slice(&(payload.len() as u32).to_le_bytes());
- out.extend_from_slice(&payload);
- out.extend_from_slice(&bytes[vp8x_end..]);
- let riff_size = u32::try_from(out.len() - 8).ok()?;
- out[4..8].copy_from_slice(&riff_size.to_le_bytes());
- Some(out)
-}
-
-pub fn gif_frame_delays_cs(bytes: &[u8]) -> Vec<u16> {
- if bytes.len() < 13 || (&bytes[..6] != b"GIF89a" && &bytes[..6] != b"GIF87a") {
- return Vec::new();
- }
- let mut offset = 13usize;
- if bytes[10] & 0x80 != 0 {
- let entries = 1usize << ((bytes[10] & 0x07) + 1);
- offset = offset.saturating_add(entries.saturating_mul(3));
- }
- let mut delays = Vec::new();
- while offset < bytes.len() {
- match bytes[offset] {
- 0x21 => {
- if offset + 1 >= bytes.len() {
- break;
- }
- if bytes[offset + 1] == 0xf9 {
- if offset + 7 >= bytes.len() || bytes[offset + 2] != 4 {
- break;
- }
- delays.push(u16::from_le_bytes([bytes[offset + 4], bytes[offset + 5]]));
- offset += 8;
- continue;
- }
- offset += 2;
- while offset < bytes.len() {
- let len = bytes[offset] as usize;
- offset += 1;
- if len == 0 {
- break;
- }
- offset = offset.saturating_add(len);
- }
- }
- 0x2c => {
- if offset + 9 >= bytes.len() {
- break;
- }
- let local_entries = if bytes[offset + 9] & 0x80 != 0 {
- 1usize << ((bytes[offset + 9] & 0x07) + 1)
- } else {
- 0
- };
- offset += 10 + local_entries * 3 + 1;
- while offset < bytes.len() {
- let len = bytes[offset] as usize;
- offset += 1;
- if len == 0 {
- break;
- }
- offset = offset.saturating_add(len);
- }
- }
- 0x3b => break,
- _ => break,
- }
- }
- delays
-}
-
-pub fn gif_loop_count(bytes: &[u8]) -> Option<u16> {
- if bytes.len() < 13 || (&bytes[..6] != b"GIF89a" && &bytes[..6] != b"GIF87a") {
- return None;
- }
- let mut offset = 13usize;
- if bytes[10] & 0x80 != 0 {
- let entries = 1usize << ((bytes[10] & 0x07) + 1);
- offset = offset.saturating_add(entries.saturating_mul(3));
- }
- while offset + 19 <= bytes.len() {
- if bytes[offset] == 0x21
- && bytes[offset + 1] == 0xff
- && bytes[offset + 2] == 11
- && (&bytes[offset + 3..offset + 14] == b"NETSCAPE2.0"
- || &bytes[offset + 3..offset + 14] == b"ANIMEXTS1.0")
- && bytes[offset + 14] == 3
- && bytes[offset + 15] == 1
- {
- return Some(u16::from_le_bytes([bytes[offset + 16], bytes[offset + 17]]));
- }
- offset += 1;
- }
- None
-}
-
-pub fn png_dimensions(bytes: &[u8]) -> Option<(u32, u32)> {
- if bytes.len() < 24 || &bytes[..8] != b"\x89PNG\r\n\x1a\n" || &bytes[12..16] != b"IHDR" {
- return None;
- }
- let width = u32::from_be_bytes([bytes[16], bytes[17], bytes[18], bytes[19]]);
- let height = u32::from_be_bytes([bytes[20], bytes[21], bytes[22], bytes[23]]);
- Some((width, height))
-}
diff --git a/fluxer_media_proxy/src/test_fixtures/jpeg_rotated_mismatched_scan.jpg b/fluxer_media_proxy/src/test_fixtures/jpeg_rotated_mismatched_scan.jpg
deleted file mode 100644
index ed8c23ad6..000000000
Binary files a/fluxer_media_proxy/src/test_fixtures/jpeg_rotated_mismatched_scan.jpg and /dev/null differ
diff --git a/fluxer_media_proxy/src/test_fixtures/jxl_4100_lossless_rgb16.jxl b/fluxer_media_proxy/src/test_fixtures/jxl_4100_lossless_rgb16.jxl
deleted file mode 100644
index dd74db6e2..000000000
Binary files a/fluxer_media_proxy/src/test_fixtures/jxl_4100_lossless_rgb16.jxl and /dev/null differ
diff --git a/fluxer_media_proxy/src/test_fixtures/jxl_4100_lossy_alpha.jxl b/fluxer_media_proxy/src/test_fixtures/jxl_4100_lossy_alpha.jxl
deleted file mode 100644
index e24db0785..000000000
Binary files a/fluxer_media_proxy/src/test_fixtures/jxl_4100_lossy_alpha.jxl and /dev/null differ
diff --git a/fluxer_media_proxy/src/test_fixtures/jxl_4100_lossy_rgb_depth.jxl b/fluxer_media_proxy/src/test_fixtures/jxl_4100_lossy_rgb_depth.jxl
deleted file mode 100644
index 773623270..000000000
Binary files a/fluxer_media_proxy/src/test_fixtures/jxl_4100_lossy_rgb_depth.jxl and /dev/null differ
diff --git a/fluxer_media_proxy/src/test_fixtures/jxl_64_lossy_alpha.jxl b/fluxer_media_proxy/src/test_fixtures/jxl_64_lossy_alpha.jxl
deleted file mode 100644
index 5eda00db4..000000000
Binary files a/fluxer_media_proxy/src/test_fixtures/jxl_64_lossy_alpha.jxl and /dev/null differ
diff --git a/fluxer_media_proxy/src/test_fixtures/jxl_7000x4000_lossy_rgb.jxl b/fluxer_media_proxy/src/test_fixtures/jxl_7000x4000_lossy_rgb.jxl
deleted file mode 100644
index ea4cf0a3b..000000000
Binary files a/fluxer_media_proxy/src/test_fixtures/jxl_7000x4000_lossy_rgb.jxl and /dev/null differ
diff --git a/fluxer_media_proxy/src/test_fixtures/media.rs b/fluxer_media_proxy/src/test_fixtures/media.rs
deleted file mode 100644
index f80ae4738..000000000
--- a/fluxer_media_proxy/src/test_fixtures/media.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-use base64::Engine as _;
-
-pub fn synthetic_wav() -> Vec<u8> {
- let sample_rate = 8_000u32;
- let channels = 1u16;
- let bits_per_sample = 8u16;
- let data_len = sample_rate;
- let byte_rate = sample_rate * u32::from(channels) * u32::from(bits_per_sample) / 8;
- let block_align = channels * bits_per_sample / 8;
- let mut wav = Vec::with_capacity(44 + data_len as usize);
- wav.extend_from_slice(b"RIFF");
- wav.extend_from_slice(&(36 + data_len).to_le_bytes());
- wav.extend_from_slice(b"WAVEfmt ");
- wav.extend_from_slice(&16u32.to_le_bytes());
- wav.extend_from_slice(&1u16.to_le_bytes());
- wav.extend_from_slice(&channels.to_le_bytes());
- wav.extend_from_slice(&sample_rate.to_le_bytes());
- wav.extend_from_slice(&byte_rate.to_le_bytes());
- wav.extend_from_slice(&block_align.to_le_bytes());
- wav.extend_from_slice(&bits_per_sample.to_le_bytes());
- wav.extend_from_slice(b"data");
- wav.extend_from_slice(&data_len.to_le_bytes());
- wav.extend(std::iter::repeat_n(128u8, data_len as usize));
- wav
-}
-
-pub fn fixture_audio_only_mp4() -> Vec<u8> {
- base64::engine::general_purpose::STANDARD
- .decode("AAAAHGZ0eXBpc29tAAACAGlzb21pc28ybXA0MQAAAxptb292AAAAbG12aGQAAAAAAAAAAAAAAAAAAAPoAAAA+gABAAABAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAACRXRyYWsAAABcdGtoZAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAA+gAAAAAAAAAAAAAAAQEAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAACRlZHRzAAAAHGVsc3QAAAAAAAAAAQAAAPoAAAQAAAEAAAAAAb1tZGlhAAAAIG1kaGQAAAAAAAAAAAAAAAAAAB9AAAAL0FXEAAAAAAAtaGRscgAAAAAAAAAAc291bgAAAAAAAAAAAAAAAFNvdW5kSGFuZGxlcgAAAAFobWluZgAAABBzbWhkAAAAAAAAAAAAAAAkZGluZgAAABxkcmVmAAAAAAAAAAEAAAAMdXJsIAAAAAEAAAEsc3RibAAAAH5zdHNkAAAAAAAAAAEAAABubXA0YQAAAAAAAAABAAAAAAAAAAAAAQAQAAAAAB9AAAAAAAA2ZXNkcwAAAAADgICAJQABAASAgIAXQBUAAAAAAD6AAAACZQWAgIAFFYhW5QAGgICAAQIAAAAUYnRydAAAAAAAAD6AAAACZQAAACBzdHRzAAAAAAAAAAIAAAACAAAEAAAAAAEAAAPQAAAAHHN0c2MAAAAAAAAAAQAAAAEAAAADAAAAAQAAACBzdHN6AAAAAAAAAAAAAAADAAAAFQAAAAQAAAAEAAAAFHN0Y28AAAAAAAAAAQAAA0YAAAAac2dwZAEAAAByb2xsAAAAAgAAAAH//wAAABxzYmdwAAAAAHJvbGwAAAABAAAAAwAAAAEAAABhdWR0YQAAAFltZXRhAAAAAAAAACFoZGxyAAAAAAAAAABtZGlyYXBwbAAAAAAAAAAAAAAAACxpbHN0AAAAJKl0b28AAAAcZGF0YQAAAAEAAAAATGF2ZjYxLjcuMTAyAAAACGZyZWUAAAAlbWRhdN4CAExhdmM2MS4xOS4xMDEAAjBADgEYIAcBGCAH")
- .unwrap()
-}
-
-pub fn fixture_audio_mp4_with_attached_picture() -> Vec<u8> {
- base64::engine::general_purpose::STANDARD
- .decode("AAAAHGZ0eXBpc29tAAACAGlzb21pc28ybXA0MQAABBNtb292AAAAbG12aGQAAAAAAAAAAAAAAAAAAAPoAAAA+gABAAABAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAACRXRyYWsAAABcdGtoZAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAA+gAAAAAAAAAAAAAAAQEAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAACRlZHRzAAAAHGVsc3QAAAAAAAAAAQAAAPoAAAQAAAEAAAAAAb1tZGlhAAAAIG1kaGQAAAAAAAAAAAAAAAAAAB9AAAAL0FXEAAAAAAAtaGRscgAAAAAAAAAAc291bgAAAAAAAAAAAAAAAFNvdW5kSGFuZGxlcgAAAAFobWluZgAAABBzbWhkAAAAAAAAAAAAAAAkZGluZgAAABxkcmVmAAAAAAAAAAEAAAAMdXJsIAAAAAEAAAEsc3RibAAAAH5zdHNkAAAAAAAAAAEAAABubXA0YQAAAAAAAAABAAAAAAAAAAAAAQAQAAAAAB9AAAAAAAA2ZXNkcwAAAAADgICAJQABAASAgIAXQBUAAAAAAAJlAAACZQWAgIAFFYhW5QAGgICAAQIAAAAUYnRydAAAAAAAAAJlAAACZQAAACBzdHRzAAAAAAAAAAIAAAACAAAEAAAAAAEAAAPQAAAAHHN0c2MAAAAAAAAAAQAAAAEAAAADAAAAAQAAACBzdHN6AAAAAAAAAAAAAAADAAAAFQAAAAQAAAAEAAAAFHN0Y28AAAAAAAAAAQAABD8AAAAac2dwZAEAAAByb2xsAAAAAgAAAAH//wAAABxzYmdwAAAAAHJvbGwAAAABAAAAAwAAAAEAAAFadWR0YQAAAVJtZXRhAAAAAAAAACFoZGxyAAAAAAAAAABtZGlyYXBwbAAAAAAAAAAAAAAAASVpbHN0AAAAJKl0b28AAAAcZGF0YQAAAAEAAAAATGF2ZjYxLjcuMTAyAAAA+WNvdnIAAADxZGF0YQAAAA0AAAAA/9j/4AAQSkZJRgABAgAAAQABAAD//gAQTGF2YzYxLjE5LjEwMQD/2wBDAAgEBAQEBAUFBQUFBQYGBgYGBgYGBgYGBgYHBwcICAgHBwcGBgcHCAgICAkJCQgICAgJCQoKCgwMCwsODg4RERT/xABMAAEBAAAAAAAAAAAAAAAAAAAABgEBAQAAAAAAAAAAAAAAAAAABgcQAQAAAAAAAAAAAAAAAAAAAAARAQAAAAAAAAAAAAAAAAAAAAD/wAARCAACAAIDASIAAhEAAxEA/9oADAMBAAIRAxEAPwCLAFF/f//ZAAAACGZyZWUAAAAlbWRhdN4CAExhdmM2MS4xOS4xMDEAAjBADgEYIAcBGCAH")
- .unwrap()
-}
-
-pub fn fixture_audio_mp3_with_png_cover_art() -> Vec<u8> {
- base64::engine::general_purpose::STANDARD
- .decode("SUQzAwAAAAABGFRTU0UAAAAPAAAATGF2ZjYyLjEyLjEwMgBBUElDAAAAawAAAGltYWdlL3BuZwAAAIlQTkcNChoKAAAADUlIRFIAAAACAAAAAggCAAAA/dSacwAAAAlwSFlzAAAAAQAAAAEATyXE1gAAABBJREFUeJxj/MMAAixgkgEADQQBAr9QFbMAAAAASUVORK5CYIIAAAAAAAAAAAAA//tAwAAAAAAAAAAAAAAAAAAAAAAASW5mbwAAAA8AAAACAAABhwC7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7u7//////////////////////////////////////////////////////////////////8AAAAATGF2YzYyLjI4AAAAAAAAAAAAAAAAJAJAAAAAAAAAAYfrk5ZRAAAAAAD/+xDEAAAEdBNVVJCAMKYJrzcaIAIAAa05QAABWTo9UFAIBgkB8HwfB8oCAIBhEHwf1Ag7E4f4g3AEk/bAYDgcDgAAAAAAKIkqmRRkCOkCSBaj94UB8BMb8CKUL6gaEvwkDSoAAFON4P/7EsQCgESkLVOdkwA4kAVoQPwwGQAEbhuG4bgcx5yaFqMmo5FPRenp43T04AIECAAAK/mHqYbyYxdYDKFIny4QlL1iQJBUZGRkuXLlq1aCgoKFBQUFBIKC1UxBTUU0LjBVVVVVVVVVVQ==")
- .unwrap()
-}
-
-pub fn fixture_jpeg() -> Vec<u8> {
- base64::engine::general_purpose::STANDARD
- .decode("/9j/2wBDAAoHBwgHBgoICAgLCgoLDhgQDg0NDh0VFhEYIx8lJCIfIiEmKzcvJik0KSEiMEExNDk7Pj4+JS5ESUM8SDc9Pjv/2wBDAQoLCw4NDhwQEBw7KCIoOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozv/wAARCAAbADADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwCLyfakMB9Kd/a8B+7Y3B/Kj+1rcplrO5B9lFe77VHgcnmQtD61XeP2q3PqlnHCZPs9ycYBAjB5P44qtPqUC3QgjtpZcjkqORxnp/8AXqfbw7lqjNq5WeP2qB4TV5b2OQgfY5F3EhS5Cg468n60yxheaaR1QGFizHL8/gOKmWJhFlRoSktC0tlcEZa5Ix7mmTw3W1Y4b2NVByxOQW+pweKLm6mjVtj4x04Bq/YSvPp8MkjbmYHJ6ZrzalRuNzWlT5XcoxWZkRXkkEjR/wDPLkdf7vrU7Wz6ltaUynyycK4Ix71fUc4ycD3rL8TzyxaJIsblQ7qjY7g9axdRvQ6Iwv1Kt/qul6aDGG+0SLwUiIIGfU9PyrJHiooT5dhGsZ52lufrWckafZAdozj/ABqrdHBwOwFPmbNY0oLof//Z")
- .unwrap()
-}
-
-pub fn fixture_h264_mp4() -> Vec<u8> {
- base64::engine::general_purpose::STANDARD
- .decode("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")
- .unwrap()
-}
-
-pub fn fixture_mkv_with_png_video_stream() -> Vec<u8> {
- base64::engine::general_purpose::STANDARD
- .decode("GkXfo6NChoEBQveBAULygQRC84EIQoKIbWF0cm9za2FCh4EEQoWBAhhTgGcBAAAAAAADKRFNm3TAv4TRygGCTbuLU6uEFUmpZlOsgaFNu4tTq4QWVK5rU6yB8U27jFOrhBJUw2dTrIIBjU27jFOrhBxTu2tTrIIC++wBAAAAAAAAUwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFUmpZsu/hDfQZgQq17GDD0JATYCNTGF2ZjYyLjEyLjEwMldBjUxhdmY2Mi4xMi4xMDJzpJCjpT5oFuxsQH+IIFgtzSyDRImIQI9AAAAAAAAWVK5rQJa/hBL4yYmuAQAAAAAAAIfXgQFzxYhQd4Ha+R0+q5yBACK1nIN1bmSIgQCDgQEj44OEHc1lAIaPVl9NUy9WRlcvRk9VUkND4JSwgRC6gRCagQJVsIhVsYEAVbmBAlXugQDsAQAAAAAAAAIAAGOiqCgAAAAQAAAAEAAAAAEAGABNUE5HAAMAAAAAAAAAAAAAAAAAAAAAAAASVMNnQH+/hDz+Y4Vzc6BjwIBnyJpFo4dFTkNPREVSRIeNTGF2ZjYyLjEyLjEwMnNz02PAi2PFiFB3gdr5HT6rZ8ieRaOHRU5DT0RFUkSHkUxhdmM2Mi4yOC4xMDIgcG5nZ8ihRaOIRFVSQVRJT05Eh5MwMDowMDowMS4wMDAwMDAwMDAAH0O2dUDjv4S0YLXX54EAo+uBAACAiVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAACXBIWXMAAAABAAAAAQBPJcTWAAAAGUlEQVR4nGNkYPjPQApgIUn1qIZRDUNKAwBsIAE94xryDgAAAABJRU5ErkJggqPrgQH0gIlQTkcNChoKAAAADUlIRFIAAAAQAAAAEAgCAAAAkJFoNgAAAAlwSFlzAAAAAQAAAAEATyXE1gAAABlJREFUeJxjZGD4z0AKYCFJ9aiGUQ1DSgMAbCABPeMa8g4AAAAASUVORK5CYIIcU7trqb+E2z26zruPs4EAt4r3gQHxggIS8IEJu5CzggH0t4r3gQHxggIS8IF2")
- .unwrap()
-}
-
-pub fn fixture_mp4_with_undecodable_video() -> Vec<u8> {
- let mut mp4 = fixture_h264_mp4();
- let mdat = mp4
- .windows(4)
- .position(|window| window == b"mdat")
- .filter(|offset| *offset >= 4)
- .expect("fixture mp4 has an mdat box");
- let box_start = mdat - 4;
- let box_size = u32::from_be_bytes([
- mp4[box_start],
- mp4[box_start + 1],
- mp4[box_start + 2],
- mp4[box_start + 3],
- ]) as usize;
- let payload_end = box_start + box_size;
- assert!(payload_end <= mp4.len() && box_size > 8);
- mp4[mdat + 4..payload_end].fill(0);
- mp4
-}
diff --git a/fluxer_media_proxy/src/test_fixtures/mod.rs b/fluxer_media_proxy/src/test_fixtures/mod.rs
deleted file mode 100644
index a8b3e4af9..000000000
--- a/fluxer_media_proxy/src/test_fixtures/mod.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-mod adversarial;
-mod ffmpeg_cli;
-mod images;
-mod media;
-
-pub use adversarial::{
- ADVERSARIAL_RANGE_HEADERS, ADVERSARIAL_TEXT_INPUTS, adversarial_media_bytes,
-};
-pub use ffmpeg_cli::{ffmpeg_gen_media, ffmpeg_gen_mp4, ffmpeg_gen_rotated_mp4, ffmpeg_mirror_mp4};
-pub use images::{
- ANIMATED_WEBP_1024_17_FRAMES, JPEG_ROTATED_MISMATCHED_SCAN, JXL_64_LOSSY_ALPHA,
- JXL_4100_LOSSLESS_RGB16, JXL_4100_LOSSY_ALPHA, JXL_4100_LOSSY_RGB_DEPTH,
- JXL_7000X4000_LOSSY_RGB, animated_gif_fixture, animated_gif_frames, apng_header,
- first_webp_anim_frame_size, gif_frame_delays_cs, gif_loop_count, minimal_gif, png_dimensions,
- synthetic_bmp, synthetic_png, webp_animation_loop_count, webp_canvas_size, webp_chunk_payloads,
- webp_with_metadata_chunk,
-};
-pub use media::{
- fixture_audio_mp3_with_png_cover_art, fixture_audio_mp4_with_attached_picture,
- fixture_audio_only_mp4, fixture_h264_mp4, fixture_jpeg, fixture_mkv_with_png_video_stream,
- fixture_mp4_with_undecodable_video, synthetic_wav,
-};
-
-mod captured_log;
-pub(crate) use captured_log::CapturedLog;
diff --git a/fluxer_media_proxy/src/thumbhash.rs b/fluxer_media_proxy/src/thumbhash.rs
index cf9e97ec1..3bc0f8c8e 100644
--- a/fluxer_media_proxy/src/thumbhash.rs
+++ b/fluxer_media_proxy/src/thumbhash.rs
@@ -188,35 +188,3 @@ fn encode_channel(
}
Ok(ChannelEncoded { dc, ac, scale })
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn encode_rejects_invalid_dimensions() {
- assert_eq!(Err(EncodeError::InvalidDimensions), encode_rgba(&[], 0, 1));
- assert_eq!(Err(EncodeError::InvalidDimensions), encode_rgba(&[], 1, 1));
- let pixels = [0u8; 101 * 4];
- assert_eq!(
- Err(EncodeError::InvalidDimensions),
- encode_rgba(&pixels, 101, 1)
- );
- }
-
- #[test]
- fn alpha_changes_header_layout() {
- let mut opaque = [0u8; 4 * 4 * 4];
- let mut translucent = [0u8; 4 * 4 * 4];
- for px in opaque.as_chunks_mut::<4>().0 {
- px[3] = 255;
- }
- for px in translucent.as_chunks_mut::<4>().0 {
- px[3] = 64;
- }
- let opaque_out = encode_rgba(&opaque, 4, 4).unwrap();
- let trans_out = encode_rgba(&translucent, 4, 4).unwrap();
- assert_eq!(0, opaque_out[2] & 0x80);
- assert_ne!(0, trans_out[2] & 0x80);
- }
-}