Strange error with tokio_util's SyncIoBridge

[ronjakoi]

I'm writing a backend service that primarily relies on image, and I'd like to use tokio's async io. The tokio_util crate comes with a type called SyncIoBridge which is intended for interfacing with sync libraries.

I tried to do this:

// use std::{collections::HashMap, io::ErrorKind, path::PathBuf};

// use tokio::{
//     fs::File,
//     io::{BufReader, Error, Result},
//     task::spawn_blocking,
// };
// use tokio_util::io::SyncIoBridge;
async fn get_image_dimensions(
    &self,
    prefix: &str,
    identifier: &str,
) -> Result<(u32, u32)> {
    let file_path: PathBuf = self.get_path(prefix, identifier)?;
    let file = File::open(&file_path).await?;
    let sync_reader = SyncIoBridge::new(BufReader::new(file));
    spawn_blocking(move || {
        let img_reader = ImageReader::new(sync_reader);
        img_reader.into_dimensions().map_err(|e| {
            Error::other(format!("Unable to get image dimensions: {e}"))
        })
    })
    .await?
}

but I get this:

Unable to get image dimensions: The image format could not be determined

The image is a PNG file that opens successfully with ImageMagick's display command, for example. You can download it here if you want.

test_image/67352ccc-d1b0-11e1-89ae-279075081939.png: PNG image data, 1000 x 1000, 8-bit/color RGB, non-interlaced

This method works with the same file in the non-tokio, sync implementation.

For just decoding the entire image, especially in the case of this PNG, it would be simple enough to just read the whole file to a buffer and then feed it to image in a spawn_blocking(), but I certainly don't want to do that just to get the dimensions. (That's the approach touched upon in #1713.)

[ronjakoi]

Hey, it actually works if I bypass the format detection:

-            let img_reader = ImageReader::new(sync_reader);
+            let mut img_reader = ImageReader::new(sync_reader);
+            img_reader.set_format(image::ImageFormat::Png);

I.e. my server responds with a 200 OK and expected response body.

[ronjakoi]

Wait a minute, does the file format detection just look at the filename extension? And the way I'm doing this here, ImageReader can no longer see the filename, so it can't detect? So I guess I can just do ImageFormat::from_extension() manually, hmm...

[fintelia]

There's two methods of format detection. The default is via file extension, but you can also run with_guessed_format to look at the initial bytes of the file to guess.

[ronjakoi]

Hell yeah, it works like this:

async fn get_image_dimensions(
    &self,
    prefix: &str,
    identifier: &str,
) -> Result<(u32, u32)> {
    let file_path = self.get_path(prefix, identifier)?;
    let file = File::open(&file_path).await?;
    let sync_reader = SyncIoBridge::new(BufReader::new(file));
    spawn_blocking(move || {
        ImageFormat::from_path(&file_path)
            .map_err(|e| Error::other(e))
            .and_then(|fmt| {
                let img_reader = ImageReader::with_format(sync_reader, fmt);
                img_reader.into_dimensions().map_err(|e| {
                    Error::other(format!(
                        "Unable to get image dimensions: {e}"
                    ))
                })
            })
    })
    .await?
}

Sorry for the noise, user error! 😄

[197g]

The conversion to discussion isn't perfect but I suggest we preserve this solution for others in this way.