音视频处理工具类

导入jar包

<!--依赖了所有平台的包 打包之后会比较大 因此使用 jave-core + 平台的包处理音视频文件-->
        <!--<dependency>
            <groupId>ws.schild</groupId>
            <artifactId>jave-all-deps</artifactId>
            <version>3.1.1</version>
        </dependency>-->

        <dependency>
            <groupId>ws.schild</groupId>
            <artifactId>jave-core</artifactId>
            <version>3.1.1</version>
        </dependency>

        <!-- 以下依赖根据系统三选一 -->
        <!-- win系统平台的依赖 -->
        <dependency>
            <groupId>ws.schild</groupId>
            <artifactId>jave-nativebin-win64</artifactId>
            <version>3.1.1</version>
        </dependency>

        <!-- linux系统平台的依赖 -->
        <!--<dependency>
            <groupId>ws.schild</groupId>
            <artifactId>jave-nativebin-linux64</artifactId>
            <version>3.1.1</version>
        </dependency>-->
        
        <!-- macos系统平台的依赖 -->
        <!--<dependency>
            <groupId>ws.schild</groupId>
            <artifactId>jave-nativebin-osx64</artifactId>
            <version>3.1.1</version>
        </dependency>-->

工具类

获取音视频大小、时长、处理音视频转码工具类

import lombok.extern.slf4j.Slf4j;
import ws.schild.jave.Encoder;
import ws.schild.jave.EncoderException;
import ws.schild.jave.MultimediaObject;
import ws.schild.jave.encode.AudioAttributes;
import ws.schild.jave.encode.EncodingAttributes;
import ws.schild.jave.encode.VideoAttributes;
import ws.schild.jave.info.MultimediaInfo;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.channels.FileChannel;

@Slf4j
public class AudioVideoUtil {

    /**
     * 获取音视频的大小
     *
     * @param source
     * @return
     */
    public static Long getSize(File source) {
        try (FileInputStream fis = new FileInputStream(source);
             FileChannel fc = fis.getChannel();) {
            return fc.size();
        } catch (IOException e) {
            log.error("AudioVideoUtil.getSize|获取文件大小 异常", e);
        }
        return -1L;
    }

    /**
     * 获取音视频的时长
     *
     * @param source
     * @return
     */
    public static Long getTime(File source) {
        try {
            MultimediaObject instance = new MultimediaObject(source);
            MultimediaInfo result = instance.getInfo();
            return result.getDuration() / 1000;
        } catch (EncoderException e) {
            log.error("AudioVideoUtil.getTime|获取音视频时长 异常", e);
        }
        return -1L;
    }

    /**
     * 音频格式转换
     *
     * @param source       原音频  本地路径
     * @param target       目标音频  本地路径
     * @param outputFormat 需要转化的格式
     */
    public static boolean audioToAudio(File source, File target, String outputFormat) {
        long start = System.currentTimeMillis();
        AudioAttributes audio = new AudioAttributes();
        audio.setCodec("libmp3lame");
        audio.setBitRate(128000);
        audio.setChannels(2);
        audio.setSamplingRate(44100);

        EncodingAttributes attrs = new EncodingAttributes();
        attrs.setOutputFormat(outputFormat);
        attrs.setAudioAttributes(audio);

        Encoder encoder = new Encoder();
        try {
            encoder.encode(new MultimediaObject(source), target, attrs);
            return true;
        } catch (EncoderException e) {
            log.error("AudioVideoUtil.audioToAudio|音频格式转码 异常", e);
        } finally {
            long end = System.currentTimeMillis();
            log.info("AudioVideoUtil.audioToAudio|音频格式转码 耗时：{} ms", end - start);
        }
        return false;
    }

    /**
     * 音频格式转换
     *
     * @param sourceUrl    原音频路径  远程路径
     * @param target       目标音频 本地路径
     * @param outputFormat 需要转化的格式
     */
    private static boolean audioToAudio(String sourceUrl, File target, String outputFormat) {
        long start = System.currentTimeMillis();
        //Audio Attributes
        AudioAttributes audio = new AudioAttributes();
        audio.setCodec("libmp3lame");
        audio.setBitRate(128000);
        audio.setChannels(2);
        audio.setSamplingRate(44100);

        //Encoding attributes
        EncodingAttributes attrs = new EncodingAttributes();
        attrs.setOutputFormat(outputFormat);
        attrs.setAudioAttributes(audio);

        //Encode
        Encoder encoder = new Encoder();
        try {
            encoder.encode(new MultimediaObject(new URL(sourceUrl)), target, attrs);
            return true;
        } catch (EncoderException e) {
            log.error("AudioVideoUtil.audioToAudio|音频格式转码 异常", e);
        } catch (MalformedURLException e) {
            log.error("AudioVideoUtil.audioToAudio|音频格式转码 异常", e);
        } finally {
            long end = System.currentTimeMillis();
            log.info("AudioVideoUtil.audioToAudio|音频格式转码 耗时：{} ms", end - start);
        }
        return false;
    }

    /**
     * 视频文件转音频文件
     *
     * @param source       原音频  本地路径
     * @param target       目标音频  本地路径
     * @param outputFormat 需要转化的格式
     */
    public static boolean videoToAudio(File source, File target, String outputFormat) {
        long start = System.currentTimeMillis();
        AudioAttributes audio = new AudioAttributes();
        audio.setCodec("libmp3lame");
        audio.setBitRate(128000);
        audio.setChannels(2);
        audio.setSamplingRate(44100);

        EncodingAttributes attrs = new EncodingAttributes();
        attrs.setOutputFormat(outputFormat);
        attrs.setAudioAttributes(audio);
        Encoder encoder = new Encoder();
        MultimediaObject mediaObject = new MultimediaObject(source);
        try {
            encoder.encode(mediaObject, target, attrs);
            return true;
        } catch (Exception e) {
            log.error("AudioVideoUtil.videoToAudio|视频转音频 异常", e);
        } finally {
            long end = System.currentTimeMillis();
            log.info("AudioVideoUtil.videoToAudio|视频转音频 耗时：{} ms", end - start);
        }
        return false;
    }

    /**
     * 视频转码
     *
     * @param source       原音频  本地路径
     * @param target       目标音频  本地路径
     * @param outputFormat 需要转化的格式
     */
    public static boolean videoToVideo(File source, File target, String outputFormat) {
        long start = System.currentTimeMillis();

        AudioAttributes audio = new AudioAttributes();
        audio.setCodec("aac");
        audio.setBitRate(236000 / 2);
        audio.setChannels(2);
        audio.setSamplingRate(8000);

        VideoAttributes video = new VideoAttributes();
        video.setCodec("h264");
        video.setBitRate(1000000);
        video.setFrameRate(25);
        video.setQuality(4);

        EncodingAttributes attrs = new EncodingAttributes();
        attrs.setOutputFormat(outputFormat);
        attrs.setAudioAttributes(audio);
        attrs.setVideoAttributes(video);

        Encoder encoder = new Encoder();
        try {
            encoder.encode(new MultimediaObject(source), target, attrs);
            return true;
        } catch (Exception e) {
            log.error("AudioVideoUtil.videoToVideo|视频格式转码 异常", e);
        } finally {
            long end = System.currentTimeMillis();
            log.info("AudioVideoUtil.videoToVideo|视频格式转码 耗时：{} ms", end - start);
        }
        return false;
    }

    public static boolean cutAudio(File source, File target, float startTime, float duration) {
        long start = System.currentTimeMillis();
        if (target.exists()) {
            target.delete();
        }
        MultimediaObject srcMultiObj = new MultimediaObject(source);
        MultimediaInfo srcMediaInfo;
        try {
            srcMediaInfo = srcMultiObj.getInfo();
            Encoder encoder = new Encoder();

            EncodingAttributes encodingAttributes = new EncodingAttributes();
            //设置起始偏移量(秒)
            encodingAttributes.setOffset(startTime);
            //设置切片的音频长度(秒)
            encodingAttributes.setDuration(duration);

            //设置音频属性
            AudioAttributes audio = new AudioAttributes();
            audio.setBitRate(srcMediaInfo.getAudio().getBitRate());
            audio.setSamplingRate(srcMediaInfo.getAudio().getSamplingRate());
            audio.setChannels(srcMediaInfo.getAudio().getChannels());

            audio.setCodec(srcMediaInfo.getAudio().getDecoder().split(" ")[0]);
            encodingAttributes.setAudioAttributes(audio);

            //写文件
            encoder.encode(srcMultiObj, target, encodingAttributes);
            return true;
        } catch (EncoderException e) {
            log.error("AudioVideoUtil.cutAudio|音视频剪辑 异常", e);
        } finally {
            long end = System.currentTimeMillis();
            log.info("AudioVideoUtil.cutAudio|音视频剪辑 耗时：{} ms", end - start);
        }
        return false;
    }

    public static void main(String[] args) {
        File source = new File("C:/xx/xx/xx/xx.mp3");
        File target = new File("C:/xx/xx/xx/xxxx.mp3");
        cutAudio(source, target, 10.0F, 30.0F);
        Long sourceTime = getTime(source);
        Long sourceSize = getSize(source);
        Long targetTime = getTime(target);
        Long targetSize = getSize(target);
        System.out.println("原音频大小：" + sourceSize + " 原音频时长：" + sourceTime);
        System.out.println("目标音频大小：" + targetSize + " 目标音频时长：" + targetTime);
    }
}