What is the best library for resizing and piping images on the backend in jvm-land?

Bytes

what do you mean by best? fastest? easiest to use? just anything that works?

Something comparable to https://github.com/lovell/sharp

i've been using https://github.com/coobird/thumbnailator, but my needs are very limited

Are you temporarily storing files on an application server or piping them to something like S3? I have thumbnailator bookmarked. A little bit concerned by the lack of activity recently, but that could just be an artifact of the library not needing maintenance.

Piping them somewhere. It's been a while since I worked on that project or used the library, but if I recall correctly it just wraps the java std lib.

actually ez enough that you don't need a library, just make an extension fnx, BOOM done.

SO folks report issues with image quality from standard Java libs

That's because people rely on the out of the box compression algos. If you wanted to you can easily impl your own given that you put in X amount of time, where X is dependent on your aptitude for picking up such task.

that sort of goes for anything, he just wants a library that he can plug in

I am asking from the context of migrating away from a node monotlith to a ktor monolith for a small business. If I have endpoints that work fine on the node monolith, it's a hard sell to sink hours into reinventing the wheel in kotlin/java-land. The node library is just a wrapper around some native code; to get equivalent performance I'd probably want to copy android's bitmap manipulation code. I'd make a strong bet android java bitmap scaling code is a wrapper around the JNI. Any work with the JNI is non-trivial.

libvips is excellent however you need a JNI wrapper

i use imagemagick with the im4java wrapper library - just make sure you are not using one of the old versions! https://github.com/stardogventures/starwizard/blob/master/starwizard-services/src/main/java/io/stardog/starwizard/services/media/resizers/ImagemagickResizer.java

why is the jvm a value here? at the end of the day you can't do much better than ffmpeg as the defacto point of gravity for image and media codec/filtering development. the value of a commandline wrapper in kotlin is questionable, you can generally write a good commandline shell template string for things that get you c-library performance and stability. even though you could access libavutil directly, you shouldn't bother with that unless you have some kind of analytical direct memory requirement

Thank you for the ffmpeg+shell recommendation. It's taken me a while to revisit this, but I was able to write a pipeline that resizes images and pipes the output directly to S3. I am searching online for some literature on how to protect an endpoint that executes commands from being hijacked. I am all ears for suggested reading or methods.

you are saying you pipe commands through something to execute remotely? chances are you are not saying you feeel insecure with ssh. with ssh you can create a remote shell. the simplest way to explain this is, with linux or git-bash in windows, 1. run

ssh-keygen -trsa -b2048

2. ssh user@remotehostname 3. mkdir .ssh;chmod 600 .ssh 4. exit 5. scp .ssh/id_rsa.pub user@remotehostname:.ssh/authorized_keys 6. ssh user@remotehostname 7. chmod 400 .ssh/authorized_keys

I am talking about the use-case of having a user on a website uploading a file via a form and having a backend service that resizes the image and pipes the output to S3.

most cloud providers have serverless ffmpeg access via messageques if you are trying to scale up. you may have to set params thru a rest api instead of the ffmpeg syntax. it is otherwise easy to build a daemon thread in main waiting for new files with json model details of what work needs to be performed and the run ProcessBuilder commands same as commandline

it's a very niche product, so scaling up is not a big concern.

the endgame for online video, (and it works for audio too) is to work out the ffmpeg DASH profiles you want to serve from the ingested content and you can build 3, 7, 12 geometries and codec bitrates for adaptive streaming clients

From the reading I've done, if you are just piping data to ffmpeg, there isn't a best practice for ensuring that that data piped in cannot execute some other arbitrary commands

one of your options is to lay the files down as segmented mp4 and webm files which can be downloaded media (about 5% overhead) but also support adaptive streaming

I might be missing something with your thoughts on adaptive streaming, but my end goal is to just resize an image the user uploads and store it in S3

i would not use pipe operator that's what i was saying about a peice of json describing the input files to process.

Ah sorry, miscommunication, I am not using the pipe operator, I am using the word pipe to describe transformating the data as it comes through and then sending the transformed data to S3

I would use discrete file name references for input and output in ffmpeg and perform the work in discrete steps almost like having a makefile, there is so much less syncronization to go wrong serverless image rescaling from AWS ... https://github.com/amazon-archives/serverless-image-resizing

what would be an example of synchronization gone wrong?

well, you can tell when things don't finish...but you may not be able to diagnose a bad input stream and reproduce failures as easliy. maybe you can control the source of media but if it's user submission you are up against thousands of vendors.

that sounds like exif issue

i guess the point is having the files that fail is key to building the pipeline to be robust, however failure occurs. ffmpeg treats images as 1-frame of video fwiw. not the other way around.

isnt there a cost to fork a new copy of ffmpeg on each request? For video this is such a small cost of the total runtime, but for images…

how slow do you presume the ffmpeg c executable to parse options and execute codecs?