feat(services/january): proxy images/videos

crates/core/files/Cargo.toml

@@ -7,6 +7,12 @@ authors = ["Paul Makles <me@insrt.uk>"]
 description = "Revolt Backend: S3 and encryption subroutines"
 
 [dependencies]
+tracing = "0.1"
+
+ffprobe = "0.4.0"
+imagesize = "0.13.0"
+tempfile = "3.12.0"
+
 base64 = "0.22.1"
 aes-gcm = "0.10.3"
 typenum = "1.17.0"
@@ -18,3 +24,10 @@ revolt-config = { version = "0.7.16", path = "../config", features = [
     "report-macros",
 ] }
 revolt-result = { version = "0.7.16", path = "../result" }
+
+# image processing
+jxl-oxide = "0.8.1"
+image = { version = "0.25.2" }
+
+# encoding
+webp = "0.3.0"

crates/core/files/src/lib.rs

@@ -1,9 +1,10 @@
-use std::io::Write;
+use std::io::{BufRead, Read, Seek, Write};
 
 use aes_gcm::{
     aead::{AeadCore, AeadMutInPlace, OsRng},
     Aes256Gcm, Key, KeyInit, Nonce,
 };
+use image::DynamicImage;
 use revolt_config::{config, report_internal_error, FilesS3};
 use revolt_result::{create_error, Result};
 
@@ -13,6 +14,7 @@ use aws_sdk_s3::{
 };
 
 use base64::prelude::*;
+use tempfile::NamedTempFile;
 
 /// Size of the authentication tag in the buffer
 pub const AUTHENTICATION_TAG_SIZE_BYTES: usize = 16;
@@ -108,3 +110,90 @@ pub async fn upload_to_s3(bucket_id: &str, path: &str, buf: &[u8]) -> Result<Str
 
     Ok(BASE64_STANDARD.encode(nonce))
 }
+
+/// Determine size of image at temp file
+pub fn image_size(f: &NamedTempFile) -> Option<(usize, usize)> {
+    if let Ok(size) = imagesize::size(f.path())
+        .inspect_err(|err| tracing::error!("Failed to generate image size! {err:?}"))
+    {
+        Some((size.width, size.height))
+    } else {
+        None
+    }
+}
+
+/// Determine size of video at temp file
+pub fn video_size(f: &NamedTempFile) -> Option<(i64, i64)> {
+    if let Ok(data) = ffprobe::ffprobe(f.path())
+        .inspect_err(|err| tracing::error!("Failed to ffprobe file! {err:?}"))
+    {
+        // Use first valid stream
+        for stream in data.streams {
+            if let (Some(w), Some(h)) = (stream.width, stream.height) {
+                return Some((w, h));
+            }
+        }
+
+        None
+    } else {
+        None
+    }
+}
+
+/// Decode image from reader
+pub fn decode_image<R: Read + BufRead + Seek>(
+    reader: &mut R,
+    is_jxl: bool,
+) -> Result<DynamicImage> {
+    if is_jxl {
+        Err(create_error!(LabelMe))
+    } else {
+        // Check if we can read using image-rs crate
+        report_internal_error!(report_internal_error!(
+            image::ImageReader::new(reader).with_guessed_format()
+        )?
+        .decode())
+    }
+}
+
+/// Check whether given reader has a valid image
+pub fn is_valid_image<R: Read + BufRead + Seek>(reader: &mut R, is_jxl: bool) -> bool {
+    if is_jxl {
+        // Check if we can read using jxl-oxide crate
+        jxl_oxide::JxlImage::builder()
+            .read(reader)
+            .inspect_err(|err| tracing::error!("Failed to read JXL! {err:?}"))
+            .is_ok()
+    } else {
+        !matches!(
+            // Check if we can read using image-rs crate
+            image::ImageReader::new(reader)
+                .with_guessed_format()
+                .inspect_err(|err| tracing::error!("Failed to read image! {err:?}"))
+                .map(|f| f.decode()),
+            Err(_) | Ok(Err(_))
+        )
+    }
+}
+
+/// Create thumbnail from given image
+pub async fn create_thumbnail(image: DynamicImage, tag: &str) -> Vec<u8> {
+    // Load configuration
+    let config = config().await;
+    let [w, h] = config.files.preview.get(tag).unwrap();
+
+    // Create thumbnail
+    //.resize(width as u32, height as u32, image::imageops::FilterType::Gaussian)
+    // resize is about 2.5x slower,
+    // thumbnail doesn't have terrible quality
+    // so we use thumbnail
+    let image = image.thumbnail(image.width().min(*w as u32), image.height().min(*h as u32));
+
+    // Encode it into WEBP
+    let encoder = webp::Encoder::from_image(&image).expect("Could not create encoder.");
+    if config.files.webp_quality != 100.0 {
+        encoder.encode(config.files.webp_quality).to_vec()
+    } else {
+        encoder.encode_lossless().to_vec()
+    }
+}