SpringBoot集成FFmpeg实现生成图片预览图与缩略图

    <profiles>
        <profile>
            <id>local</id>
            <properties>
                <profiles.active>local</profiles.active>
                <!--根据环境进行切换-->
                <ffmpeg.classifier>windows-x86_64</ffmpeg.classifier>
<!--                <ffmpeg.classifier>linux-x86_64</ffmpeg.classifier>-->
            </properties>
        </profile>
    </profiles> 

        <!-- javacv+javacpp核心库-->
        <dependency>
            <groupid>org.bytedeco</groupid>
            <artifactid>javacv</artifactid>
            <version>${javacv.version}</version>
        </dependency>
        <dependency>
            <groupid>org.bytedeco</groupid>
            <artifactid>javacpp-platform</artifactid>
            <version>${javacv.version}</version>
        </dependency>

        <!-- ffmpeg最小依赖包，必须包含上面的javacv+javacpp核心库 -->
        <dependency>
            <groupid>org.bytedeco</groupid>
            <artifactid>ffmpeg</artifactid>
            <version>5.1.2-${javacv.version}</version>
            <classifier>${ffmpeg.classifier}</classifier>
        </dependency>
        <dependency>
            <groupid>org.bytedeco</groupid>
            <artifactid>javacpp</artifactid>
            <version>${javacv.version}</version>
            <classifier>${ffmpeg.classifier}</classifier>
        </dependency>
        <dependency>
            <groupid>org.bytedeco</groupid>
            <artifactid>openblas</artifactid>
            <version>0.3.21-${javacv.version}</version>
            <classifier>${ffmpeg.classifier}</classifier>
        </dependency>
        <dependency>
            <groupid>org.bytedeco</groupid>
            <artifactid>opencv</artifactid>
            <version>4.6.0-${javacv.version}</version>
            <classifier>${ffmpeg.classifier}</classifier>
        </dependency>

package xxxx;

import cn.hutool.core.io.fileutil;
import cn.hutool.core.io.ioutil;
import cn.hutool.core.lang.uuid;
import lombok.extern.slf4j.slf4j;
import org.bytedeco.javacv.ffmpegframerecorder;
import org.bytedeco.javacv.frame;
import org.bytedeco.javacv.java2dframeconverter;
import org.springframework.stereotype.component;

import javax.imageio.imageio;
import java.awt.*;
import java.awt.image.bufferedimage;
import java.io.file;
import java.io.fileinputstream;
import java.io.ioexception;
import java.io.inputstream;
import java.net.httpurlconnection;
import java.net.url;

/**
 * 图片预览图处理器
 *
 * @author god_cvz
 */
@component
@slf4j
public class picturepreviewprocessor {

    /**
     * 异步执行，防止阻碍主流程，建议使用线程池
     *
     * @param pictureurl
     */
    public void asyncprocess(string pictureurl) {
        new thread(() -> process(pictureurl)).start();
    }

    public void process(string pictureurl) {
        log.info("开始处理照片 pictureurl: {}", pictureurl);
        try (inputstream inputstream = getinputstreamfromurl(pictureurl)) {
            // 安全地重置一个输入流以重新读取图像数据，若流不支持重置，则从网络重新下载图像‌，确保图像处理流程的可靠性
            if (inputstream.marksupported()) {
                // 将流指针归位，复用原流，避免重复下载，提升效率与节省带宽
                inputstream.reset();
                processimage(inputstream);
            } else {
                try (inputstream newinputstream = getinputstreamfromurl(pictureurl)) {
                    processimage(newinputstream);
                }
            }
        } catch (exception e) {
            log.error("处理照片失败: {}", e.getmessage());
        }
    }

    /**
     * 从指定 url 下载资源并返回 inputstream
     *
     * @param urlstring 资源的 url 地址
     * @return inputstream （需要调用方手动关闭）
     * @throws ioexception 下载或连接失败时抛出异常
     */
    public inputstream getinputstreamfromurl(string urlstring) throws exception {
        if (urlstring == null || urlstring.isempty()) {
            throw new illegalargumentexception("url 不能为空");
        }
        log.info("[downloadutils] 开始下载文件：{}", urlstring);
        long starttime = system.currenttimemillis();

        try {
            url url = new url(urlstring);
            httpurlconnection connection = (httpurlconnection) url.openconnection();
            connection.setrequestmethod("get");
            connection.setconnecttimeout(10_000);
            connection.setreadtimeout(15_000);
            connection.setdoinput(true);
            // 检查响应码
            int responsecode = connection.getresponsecode();
            if (responsecode != httpurlconnection.http_ok) {
                throw new ioexception("下载失败，http 响应码：" + responsecode);
            }
            log.info("[downloadutils] 连接成功[{}]，开始接收数据...", url);
            inputstream inputstream = connection.getinputstream();
            long endtime = system.currenttimemillis();
            log.info("[downloadutils] 下载完成，用时 {} ms", (endtime - starttime));
            return inputstream;
        } catch (exception e) {
            log.error("[downloadutils] 下载文件失败[{}], error:{}", urlstring, e.getmessage());
            throw new exception("[downloadutils] 下载文件失败: " + e.getmessage());
        }
    }

    private void processimage(inputstream inputstream) throws ioexception {
        bufferedimage sourceimage = imageio.read(inputstream);
        // 生成预览图
        generatepreview(sourceimage);
        // 生成缩略图
        generatethumbnail(sourceimage);
        // 生成webp缩略图
        generatewebp(sourceimage);
    }

    private void generatepreview(bufferedimage sourceimage) {
        // 预览图宽度
        int previewwidth = 720;
        // 预览图高度
        int previewheight = 540;
        string previewfilename = uuid.randomuuid() + ".jpg";
        string objectkey = "/bucket/preview/" + previewfilename;
        uploadimage(sourceimage, previewwidth, previewheight, objectkey, previewfilename);
    }

    private void generatethumbnail(bufferedimage sourceimage) {
        // 缩略图宽度
        int thumbnailwidth = 200;
        // 缩略图高度
        int thumbnailheight = 150;
        string thumbnailfilename = uuid.randomuuid() + ".jpg";
        string objectkey = "/bucket/thumbnail/" + thumbnailfilename;
        uploadimage(sourceimage, thumbnailwidth, thumbnailheight, objectkey, thumbnailfilename);
    }

    private void uploadimage(bufferedimage sourceimage, integer targetwith, integer targetheight, string objectkey, string filename) {
        file outputfile = new file(filename);
        fileinputstream fileinputstream = null;
        try {
            int[] changesize = this.getchangesize(sourceimage.getwidth(), sourceimage.getheight(), targetwith, targetheight);
            // 创建目标文件缓冲区
            bufferedimage outputimage = this.resizeimage(sourceimage, changesize[0], changesize[1]);
            // 保存图片到文件
            imageio.write(outputimage, "jpg", outputfile);
            fileinputstream = new fileinputstream(outputfile);
            // 上传至oss
            this.uploadfile(fileinputstream, objectkey);
            log.info("生成图片成功: objectkey: {}", objectkey);
        } catch (exception e) {
            log.error("生成图片失败: objectkey: {}, 原因: {}", objectkey, e.getmessage());
        } finally {
            ioutil.closeifposible(fileinputstream);
            fileutil.del(outputfile);
        }
    }

    /**
     * 计算图像 按比例缩放后的宽高
     * 选择宽高缩放后较大的一边，固定其长度，另一边按原图比例缩放
     *
     * @param originalwidth  图像原宽度
     * @param originalheight 图像原长度
     * @param targetwidth    目标宽度
     * @param targetheight   目标高度
     * @return int[]
     */
    public int[] getchangesize(int originalwidth, int originalheight, int targetwidth, int targetheight) {
        // 设置缩放比例
        double scale = math.min(targetwidth / (double) originalwidth, targetheight / (double) originalheight);
        // 计算缩放后的宽高
        return new int[]{(int) (originalwidth * scale), (int) (originalheight * scale)};
    }

    /**
     * 修改图片尺寸
     *
     * @param originimage  原图文件
     * @param targetwidth  目标宽度
     * @param targetheight 目标高度
     * @return 制定尺寸图片
     */
    public bufferedimage resizeimage(bufferedimage originimage, int targetwidth, int targetheight) {
        bufferedimage resizedimage = new bufferedimage(targetwidth, targetheight, bufferedimage.type_int_rgb);
        graphics2d graphics = resizedimage.creategraphics();
        graphics.drawimage(originimage, 0, 0, targetwidth, targetheight, null);
        graphics.dispose();
        return resizedimage;
    }

    /**
     * todo:自定义上传至oss文件存储服务器
     *
     * @param fileinputstream 文件流
     * @param objectkey       oss存储key
     */
    private void uploadfile(fileinputstream fileinputstream, string objectkey) {

    }

    private void generatewebp(bufferedimage sourceimage) {
        string webpfilename = uuid.randomuuid() + ".webp";
        string objectkey = "/bucket/webp/" + webpfilename;
        uploadwebp(sourceimage, objectkey, webpfilename);
    }

    private void uploadwebp(bufferedimage sourceimage, string objectkey, string filename) {
        // 将bufferedimage转换为frame
        java2dframeconverter converter = new java2dframeconverter();
        frame frame = converter.convert(sourceimage);
        file outputfile = new file(filename);
        fileinputstream inputstream = null;
        // 设置输出图像的参数
        try (ffmpegframerecorder recorder = new ffmpegframerecorder(outputfile, frame.imagewidth, frame.imageheight)) {
            recorder.setformat("webp");
            // 记录frame
            recorder.start();
            recorder.record(frame);
            recorder.stop();
            inputstream = new fileinputstream(outputfile);
            this.uploadfile(inputstream, objectkey);
            log.info("生成webp成功: objectkey: {}", objectkey);
        } catch (exception | error e) {
            log.error("生成webp失败: objectkey: {} - 原因: {}", objectkey, e.getmessage());
        } finally {
            ioutil.closeifposible(inputstream);
            ioutil.closeifposible(converter);
            fileutil.del(outputfile);
        }
    }
}