public BufferedImage generateImage(String url) {
    log.info("generateImage...url: {}", url);

    URL url0;
    try {
        url0 = new URL(url);
    } catch (MalformedURLException e) {
        throw new RuntimeException(e);
    }
    BufferedImage bufferedImage;
    try {
        bufferedImage = ImageIO.read(url0);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    return bufferedImage;
}

/**
 * 生成二维码
 */
public BufferedImage generateQrCode(String text, int width, int height) {
    log.info("generateQrCode...text: {}, width: {}, height: {}", text, width, height);

    // 生成二维码BitMatrix
    BitMatrix bitMatrix;
    try {
        // 不能按指定大小生成，先按自动大小生成，在convertToDotMatrixImage方法中缩放
        bitMatrix = new QRCodeWriter().encode(text, BarcodeFormat.QR_CODE, 0, 0, this.hints);
    } catch (WriterException e) {
        throw new RuntimeException(e);
    }
    // 转换为点阵图像
    return this.convertToDotMatrixImage(bitMatrix, width, height);
}

/**
 * 生成条形码
 */
public BufferedImage generateBarCode(String text, int width, int height) {
    log.info("drawBarCode...text: {}, width: {}, height: {}", text, width, height);

    // 生成条形码BitMatrix
    BitMatrix bitMatrix = new Code128Writer().encode(text, BarcodeFormat.CODE_128, 0, 0);
    // 转换为点阵图像
    return this.convertToDotMatrixImage(bitMatrix, width, height);
}

/**
 * 将BitMatrix转换为点阵图像BufferedImage
 * 生成二维码场景，当指定90x90，会生成49x49（bitMatrix尺寸是90x90但是内容是49x49居中）的二维码，需要进行缩放
 */
private BufferedImage convertToDotMatrixImage(BitMatrix bitMatrix, int desiredWidth, int desiredHeight) {
    // 缩放二维码
    BufferedImage qrImage = MatrixToImageWriter.toBufferedImage(bitMatrix);
    BufferedImage scaledImage = new BufferedImage(desiredWidth, desiredHeight, BufferedImage.TYPE_BYTE_BINARY);
    Graphics2D g = scaledImage.createGraphics();
    g.drawImage(qrImage, 0, 0, desiredWidth, desiredHeight, null);
    g.dispose();

    return scaledImage;
}

    /**
     * 生成文本图像
     */
    private BufferedImage generateTextImage(String text) throws IOException {
        // 获取字体文件对象
//        RandomAccessFile fontFile = this.getFontFile(this.fontFileName);

        int fontWidth = this.fontWidth;
        int fontHeight = this.fontHeight;
        int byteCount = this.byteCount;

        int textLength = text.length();

        // list of char[][] 存放每个字符的点阵数据
        ArrayList<char[][]> dotMatList = new ArrayList<>(textLength);

        // 绘制每个字符
        for (int i = 0; i < textLength; i++) {
            char word = text.charAt(i);

            // 获取字符码点
            int codePoint = this.getCodePoint(String.valueOf(word));
            // 修正24宽度字体的码点 ; 原因未知，copy自php版逻辑
            codePoint = this.fixCodePointWhenFontWidth24(codePoint);
            // 计算在字体文件中的位置
            int position = codePoint * byteCount;
            // 获取字体数据
//            byte[] fontData = this.getFontData(fontFile, position, byteCount);
            // fix: resources下的文件在打成jar后使用(RandomAccess)File读取失败，改为直接加载byte[]缓存到内存
            byte[] fontData = this.readFontData(this.fontFileName, position, byteCount);
            // convert to mat
            char[][] dotMat = this.convertBytesToDotMat(fontData, fontHeight, fontWidth);

            // 获取字符实际宽度
            int realWidth = codePoint < 700 ? this.fontEn : this.fontZh;
            // 按实际宽度切割重组
            for (int j = 0; j < fontHeight; j++) {
                // 自动宽度逻辑
                realWidth = this.autoWidth ? this.getCharWidth(dotMat, this.fontZh, this.fontWidth) : realWidth;
                // 空格间距逻辑
                realWidth = codePoint == this.SPACE_CODE_POINT ? this.SPACE_WIDTH : realWidth;
                // 按实际宽度切割
                char[] row = dotMat[j];
                char[] newRow = new char[realWidth];
                System.arraycopy(row, 0, newRow, 0, realWidth);
                // 加粗逻辑
                newRow = this.setBold(newRow, this.bold);
                // 字间距逻辑
                newRow = this.setSpacing(newRow, this.fontSpace);

                dotMat[j] = newRow;
            }
            // dotMat根据最长的长度补齐尾部
            this.padDotMat(dotMat);

            // 打印
//            this.printDotMat(dotMat);
            // 加入集合
            dotMatList.add(dotMat);
        }

        // 整合所有dotMat from dotMatList
        char[][] finalDotMat = this.mergeDotMat(dotMatList);

        // 保存文本点阵宽度和高度
        this.textBitWidth = finalDotMat[0].length;
        this.textBitHeight = finalDotMat.length;

        // 将所有dotMat绘制到图像
        BufferedImage textImage = new BufferedImage(finalDotMat[0].length, fontHeight, BufferedImage.TYPE_BYTE_BINARY);
        this.renderDotMatToImage(finalDotMat, textImage, 0, 0);

//        fontFile.close();

        return textImage;
    }

    /**
     * 获取码点
     */
    private int getCodePoint(String str) {
        int codePoint = 0;
        try {
            // 获取字符串的代码点
            codePoint = str.codePointAt(0);
        } catch (IndexOutOfBoundsException e) {
            // 处理字符串为空或其他异常情况
            e.printStackTrace();
        }
        // 字符越界处理
        if (codePoint > 65535) {
            codePoint = 0;
        }
        return codePoint;
    }

    /**
     * 修正24宽度字体的码点
     * 将超出范围的码点修正为空格码点
     */
    private int fixCodePointWhenFontWidth24(int codePoint) {
        if (this.fontWidth == 24) {
            if (codePoint <= this.SPACE_CODE_POINT || codePoint > this.fontMaxPosition) {
                codePoint = this.SPACE_CODE_POINT;
            }
        }
        return codePoint;
    }

    /**
     * 转换字节数组为点阵多维数组
     */
    private char[][] convertBytesToDotMat(byte[] fontData, int fontHeight, int fontWidth) {
        // fontData bit -> char[]
        char[] dots = new char[fontHeight * fontWidth];
        for (int i = 0; i < fontData.length; i++) {
            byte b = fontData[i];
            for (int bit = 7; bit >= 0; bit--) {
                int bitValue = (b >> bit) & 1;
                dots[i * 8 + (7 - bit)] = bitValue == 1 ? '1' : '0';
            }
        }
        // char[] -> char[][] by fontWidth
        char[][] dotMat = new char[fontHeight][fontWidth];
        for (int i = 0; i < fontHeight; i++) {
            System.arraycopy(dots, i * fontWidth, dotMat[i], 0, fontWidth);
        }
        return dotMat;
    }

    /**
     * 加粗逻辑
     */
    private char[] setBold(char[] dot, boolean fontBold) {
        if (!fontBold) {
            return dot;
        }

        char[] result = new char[dot.length];
        for (int i = 0; i < dot.length; i++) {
            char current = dot[i];
            char shifted = i == 0 ? '0' : dot[i - 1]; // 前一个字符，用'0'补齐
            result[i] = (current == '1' || shifted == '1') ? '1' : '0';
        }

        return result;
    }

    /**
     * 字间距逻辑
     */
    private char[] setSpacing(char[] dotArray, int spacing) {
        if (spacing <= 0) {
            return dotArray; // 如果 spacing <= 0，直接返回原数组
        }

        char[] result = new char[dotArray.length + spacing];
        int index = 0;

        for (char c : dotArray) {
            result[index++] = c;
        }

        // 添加字间距
        for (int i = 0; i < spacing; i++) {
            result[index++] = '0';
        }

        return result;
    }

    /**
     * 对齐点阵尾部
     */
    private void padDotMat(char[][] dotMat) {
        // 先获取最长的长度
        int maxRowLength = 0;
        for (char[] row : dotMat) {
            maxRowLength = Math.max(maxRowLength, row.length);
        }
        // dotMat根据最长的长度补齐尾部
        for (int k = 0; k < dotMat.length; k++) {
            char[] row = dotMat[k];
            char[] newRow = new char[maxRowLength];
            System.arraycopy(row, 0, newRow, 0, row.length);
            for (int j = row.length; j < maxRowLength; j++) {
                newRow[j] = '0';
            }
            dotMat[k] = newRow;
        }
    }

    /**
     * 合并多个点阵
     */
    private char[][] mergeDotMat(ArrayList<char[][]> dotMatList) {
        // 计算最终宽度
        int finalWidth = this.calcFinalWidth(dotMatList);
        int fontHeight = this.fontHeight;
        char[][] finalDotMat = new char[fontHeight][finalWidth];
        int columnIndex = 0;
        for (char[][] chars : dotMatList) {
            int rowIndex = 0;
            for (char[] aChar : chars) {
                System.arraycopy(aChar, 0, finalDotMat[rowIndex++], columnIndex, aChar.length);
            }
            columnIndex += chars[0].length;
        }
        return finalDotMat;
    }

    /**
     * 计算最终宽度
     */
    private int calcFinalWidth(ArrayList<char[][]> dotMatList) {
        int finalWidth = 0;
        for (char[][] dotMat : dotMatList) {
            finalWidth += dotMat[0].length;
        }
        return finalWidth;
    }

    /**
     * 将dotMat绘制到图像
     */
    private void renderDotMatToImage(char[][] dotMat, BufferedImage image, int x, int y) {
        for (int j = 0; j < dotMat.length; j++) {
            char[] row = dotMat[j];
            for (int k = 0; k < row.length; k++) {
                char bitValue = dotMat[j][k];
                image.setRGB(x + k, y + j, bitValue == '1' ? Color.BLACK.getRGB() : Color.WHITE.getRGB());
            }
        }
    }

private final Map<String, byte[]> fontFileDataMap = new ConcurrentHashMap<>();

private byte[] readFontData(String fontFileName, int position, int byteCount) throws IOException {
    byte[] fontFileData = fontFileDataMap.get(fontFileName);
    if (fontFileData == null) {
        fontFileData = this.loadFontFileData(fontFileName);
    }

    byte[] fontData = new byte[byteCount];
    System.arraycopy(fontFileData, position, fontData, 0, byteCount);
    return fontData;
}

private synchronized byte[] loadFontFileData(String resourcePath) throws IOException {
    // 检查并发场景下其他线程是否已加载，避免重复加载
    byte[] fontFileData = fontFileDataMap.get(fontFileName);
    if (fontFileData != null) {
        return fontFileData;
    }

    try (InputStream inputStream = LatticeText.class.getClassLoader().getResourceAsStream(resourcePath);
         ByteArrayOutputStream buffer = new ByteArrayOutputStream()) {
        if (inputStream == null) {
            throw new IOException("Resource not found: " + resourcePath);
        }

        byte[] data = new byte[1024];
        int bytesRead;

        // Read the input stream into the byte array output stream
        while ((bytesRead = inputStream.read(data, 0, data.length)) != -1) {
            buffer.write(data, 0, bytesRead);
        }

        // Return the byte array
        fontFileData = buffer.toByteArray();
        fontFileDataMap.put(fontFileName, fontFileData);
        return fontFileData;
    }
}

/**
 * 转码并返回音频时长
 */
public Double transcoding(String ffmpegPath, String input, String output) {
    String info = output + ".info";
    FileUtil.touch(info);
    String[] ffmpegCommand = {
            ffmpegPath,
            "-hide_banner",
            "-y",
            // ... 其他参数
            "-i", input, output,
            "2>&1 | cat >", info
    };
    List<String> listCommand = CollUtil.newArrayList(ffmpegCommand);

    String finalCommandStr = StrUtil.join(" ", listCommand);
    log.info("finalCommandStr: {}", finalCommandStr);

    int exitCode = -1;
    try {
//        ProcessBuilder pb = new ProcessBuilder(listCommand);
        // 如果有重定向的逻辑，一定要这样调用！！！
        ProcessBuilder pb = new ProcessBuilder("/bin/sh", "-c", String.join(" ", listCommand));
        Process process = pb.inheritIO().start();
        exitCode = process.waitFor();
        process.destroy();
    } catch (Exception e) {
        e.printStackTrace();
    }

    log.info("exitCode: {}", exitCode);

    // 获取音频时长
    Double length = this.getAudioLength(info);
    FileUtil.del(info);

    return length;
}

/**
 * 获取音频时长
 */
private Double getAudioLength(String infoFile) {
    Double durationInSeconds = null;  // 初始化为 null

    // 读取infoFile，提取音频时长信息
    List<String> lines = FileUtil.readLines(infoFile, "UTF-8");
    for (String line : lines) {
        if (line.contains("Duration:")) {
            // 提取包含 "Duration:" 的行
            String durationLine = line.trim();
            String durationPart = durationLine.split("Duration:")[1].trim().split(",")[0].trim();

            // 解析时长信息，转换为 Double，精确到毫秒
            String[] timeParts = durationPart.split(":");
            double hours = Double.parseDouble(timeParts[0]);
            double minutes = Double.parseDouble(timeParts[1]);
            double seconds = Double.parseDouble(timeParts[2]);
            double milliseconds = (hours * 3600 + minutes * 60 + seconds) * 1000;

            durationInSeconds = milliseconds / 1000.0;  // 转换为秒
        }
    }
    return durationInSeconds;
}

package com.yeshimin.test.jni;

import java.lang.reflect.Field;
import java.util.Arrays;

public class JniTest {

    // 设置dll加载路径
    static {
        try {
            String path = "C:\\Users\\ysd\\IdeaProjects\\test\\dll";
            // 无效
//            System.setProperty("java.library.path", path);
            // 需要使用这种方式
            // 参考：https://fahdshariff.blogspot.com/2011/08/changing-java-library-path-at-runtime.html
            addLibraryPath(path);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        System.loadLibrary("jnitest");
    }

    /**
     * Adds the specified path to the java library path
     *
     * @param pathToAdd the path to add
     * @throws Exception
     */
    public static void addLibraryPath(String pathToAdd) throws Exception {
        final Field usrPathsField = ClassLoader.class.getDeclaredField("usr_paths");
        usrPathsField.setAccessible(true);

        // get array of paths
        final String[] paths = (String[]) usrPathsField.get(null);

        // check if the path to add is already present
        for (String path : paths) {
            if (path.equals(pathToAdd)) {
                return;
            }
        }

        //add the new path
        final String[] newPaths = Arrays.copyOf(paths, paths.length + 1);
        newPaths[newPaths.length - 1] = pathToAdd;
        usrPathsField.set(null, newPaths);
    }

    // ================================================================================

    // 本地方法
    private static native String sayHello(String name);

    public static void main(String[] args) {
        String result = sayHello("ysm");
        System.out.println("result: " + result);
    }
}

package com.yeshimin.test.jni;

import java.lang.reflect.Field;
import java.util.Arrays;

public class JniTest {

    // 设置dll加载路径
    static {
        // 略...

        System.loadLibrary("jnitestinternal");
    }

    // 本地方法
    private static native String sayHelloInternal(String name);

    public static void main(String[] args) {
        String result = sayHelloInternal("ysm");
        System.out.println("result: " + result);
    }
}

package com.yeshimin.test.jni;

import java.lang.reflect.Field;
import java.util.Arrays;

public class JniTest {

    // 设置dll加载路径
    static {
        // 略...

        System.loadLibrary("jnitest");
        System.loadLibrary("jnitestinternal"); // 依赖的dll也要加载
    }

    private static native String sayHello(String name);

    private static native String sayHelloByProxy(String name);

    private static native String sayHelloInternal(String name);

    public static void main(String[] args) {

        // 调用同包名下的本地方法；执行成功
        String result = sayHello("ysm");
        System.out.println("result: " + result);

        // “代理”方式下，调用不同包名下的本地方法；执行成功
        String result2 = sayHelloByProxy("ysm");
        System.out.println("result2: " + result2);

        // 调用不同包名下的本地方法；执行报错
        String result3 = sayHelloInternal("ysm");
        System.out.println("result3: " + result3);
    }
}

package com.yeshimin.test.jni;

import java.lang.reflect.Field;
import java.util.Arrays;

public class JniTest {

    // 设置dll加载路径
    static {
        // 略...

        System.loadLibrary("jnitest");
        System.loadLibrary("jnitestinternal"); // 依赖的dll也要加载
    }

    private static native int dynamicInvoke();

    public static void main(String[] args) {
        int intResult = dynamicInvoke();
        System.out.println("intResult: " + intResult);
    }
}

    @Override
    public int transcoding(String input, String output) throws IOException, InterruptedException {
        String[] ffmpegCommand = {
                "/usr/bin/ffmpeg",  // linux
//                "/opt/homebrew/bin/ffmpeg", // macos
                "-hide_banner",
                "-i", input,
                "-ar", "16000",
                "-ab", "32k",
                "-ac", "1",
                "-write_xing", "0",
                "-map_metadata", "-1",
                "-fflags", "+bitexact",
                "-flags:a", "+bitexact",
                "-c:a", "libmp3lame",
                output
        };

        ProcessBuilder pb = new ProcessBuilder(ffmpegCommand);
        int exitCode = pb.inheritIO().start().waitFor();
        log.info("transcoding.exitCode: {}", exitCode);
        return exitCode;
    }

    private Double getAudioLength(String input) {
        String infoFile = input + ".info";
        String[] ffmpegCommand = {
                "/usr/bin/ffmpeg",  // linux
//                "/opt/homebrew/bin/ffmpeg", // macos
                "-hide_banner",
                "-i", input,
                "2>&1", "|", "cat",
                ">", infoFile
        };

        Double durationInSeconds = null;  // 初始化为 null

        try {
//            ProcessBuilder pb = new ProcessBuilder(ffmpegCommand);
            // 如果有重定向的逻辑，一定要这样调用！！！
            ProcessBuilder pb = new ProcessBuilder("/bin/sh", "-c", String.join(" ", ffmpegCommand));
            Process process = pb.inheritIO().start();
            int exitCode = process.waitFor();
            log.info("exitCode: {}", exitCode);

            // 读取infoFile，提取音频时长信息
            List<String> lines = FileUtil.readLines(infoFile, "UTF-8");
            for (String line : lines) {
                if (line.contains("Duration:")) {
                    // 提取包含 "Duration:" 的行
                    String durationLine = line.trim();
                    String durationPart = durationLine.split("Duration:")[1].trim().split(",")[0].trim();

                    // 解析时长信息，转换为 Double，精确到毫秒
                    String[] timeParts = durationPart.split(":");
                    double hours = Double.parseDouble(timeParts[0]);
                    double minutes = Double.parseDouble(timeParts[1]);
                    double seconds = Double.parseDouble(timeParts[2]);
                    double milliseconds = (hours * 3600 + minutes * 60 + seconds) * 1000;

                    durationInSeconds = milliseconds / 1000.0;  // 转换为秒
                }
            }

            process.destroy();

            if (durationInSeconds != null) {
                log.info("音频时长（秒，精确到毫秒）：{}", durationInSeconds);
            } else {
                log.info("未找到音频时长信息。");
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            FileUtil.del(infoFile);
        }

        return durationInSeconds;
    }