init

.gitignore

@@ -0,0 +1,37 @@
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store
+
+*.log

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/git_toolbox_blame.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GitToolBoxBlameSettings">
+    <option name="version" value="2" />
+  </component>
+</project>

.idea/misc.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ExternalStorageConfigurationManager" enabled="true" />
+  <component name="MavenProjectsManager">
+    <option name="originalFiles">
+      <list>
+        <option value="$PROJECT_DIR$/pom.xml" />
+      </list>
+    </option>
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

pom.xml

@@ -0,0 +1,286 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.tzld.ffmpeg</groupId>
+    <artifactId>ffmpeg-command</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <parent>
+        <groupId>com.tzld.commons</groupId>
+        <artifactId>supom</artifactId>
+        <version>1.0.6</version>
+    </parent>
+
+    <properties>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss.SSS</maven.build.timestamp.format>
+        <mavenBuildTime>${maven.build.timestamp}</mavenBuildTime>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.mybatis.spring.boot</groupId>
+            <artifactId>mybatis-spring-boot-starter</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.github.pagehelper</groupId>
+            <artifactId>pagehelper-spring-boot-starter</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-aop</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>io.lettuce</groupId>
+            <artifactId>lettuce-core</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-pool2</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-collections4</artifactId>
+            <version>4.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.mybatis.generator</groupId>
+            <artifactId>mybatis-generator-core</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+        </dependency>
+
+        <!-- druid数据源 -->
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>druid</artifactId>
+            <version>1.1.23</version>
+        </dependency>
+        <!--easyexcel-->
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>easyexcel</artifactId>
+            <version>3.0.5</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.baomidou</groupId>
+            <artifactId>mybatis-plus-boot-starter</artifactId>
+            <version>3.5.3.2</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.12</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+            <version>4.5.14</version> <!-- 使用最新版本 -->
+        </dependency>
+
+        <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpmime -->
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpmime</artifactId>
+            <version>4.5.14</version>
+        </dependency>
+
+        <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpcore -->
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpcore</artifactId>
+            <version>4.4.16</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>31.1-jre</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>fastjson</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.aliyun.odps</groupId>
+            <artifactId>odps-sdk-core</artifactId>
+            <version>0.27.2-public</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.aliyun.oss</groupId>
+            <artifactId>aliyun-sdk-oss</artifactId>
+            <version>3.17.4</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.xuxueli</groupId>
+            <artifactId>xxl-job-core</artifactId>
+        </dependency>
+
+        <!-- https://mvnrepository.com/artifact/commons-codec/commons-codec -->
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+            <version>1.17.1</version>
+        </dependency>
+
+        <!--XML 解析包-->
+        <dependency>
+            <groupId>org.jdom</groupId>
+            <artifactId>jdom2</artifactId>
+            <version>2.0.6</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.aliyun.openservices</groupId>
+            <artifactId>ons-client</artifactId>
+            <version>1.8.4.Final</version>
+        </dependency>
+
+        <!-- https://mvnrepository.com/artifact/com.ctrip.framework.apollo/apollo-client -->
+        <dependency>
+            <groupId>com.ctrip.framework.apollo</groupId>
+            <artifactId>apollo-client</artifactId>
+            <version>2.0.0</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.aliyun.openservices</groupId>
+            <artifactId>aliyun-log-producer</artifactId>
+            <version>0.3.10</version>
+        </dependency>
+        <dependency>
+            <groupId>com.aliyun.openservices</groupId>
+            <artifactId>aliyun-log-logback-appender</artifactId>
+            <version>0.1.18</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>com.google.protobuf</groupId>
+                    <artifactId>protobuf-java</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <!-- 强制使用兼容的 Protobuf 版本 -->
+        <dependency>
+            <groupId>com.google.protobuf</groupId>
+            <artifactId>protobuf-java</artifactId>
+            <version>3.20.1</version> <!-- 使用与阿里云 SDK 兼容的版本 -->
+        </dependency>
+
+        <dependency>
+            <groupId>io.springfox</groupId>
+            <artifactId>springfox-swagger2</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.springfox</groupId>
+            <artifactId>springfox-swagger-ui</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.aliyun</groupId>
+            <artifactId>alibabacloud-dysmsapi20170525</artifactId>
+            <version>2.0.23</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.tzld.commons</groupId>
+            <artifactId>aliyun-log-spring-boot-starter</artifactId>
+            <version>2.0.0</version>
+            <exclusions>
+                <exclusion>
+                    <artifactId>aliyun-log</artifactId>
+                    <groupId>com.aliyun.openservices</groupId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>com.stuuudy.commons</groupId>
+            <artifactId>commons-external</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+        </dependency>
+
+        <!-- Eureka 客户端 -->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
+        </dependency>
+
+        <!-- OpenFeign -->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-openfeign</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+            <version>5.8.18</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.msgpack</groupId>
+            <artifactId>msgpack-core</artifactId>
+            <version>0.9.9</version>
+        </dependency>
+        <dependency>
+            <groupId>org.msgpack</groupId>
+            <artifactId>jackson-dataformat-msgpack</artifactId>
+            <version>0.9.9</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.hankcs</groupId>
+            <artifactId>hanlp</artifactId>
+            <version>portable-1.8.6</version>
+        </dependency>
+
+    </dependencies>
+
+</project>

src/main/java/com/tzld/ffmpeg/Application.java

@@ -0,0 +1,31 @@
+package com.tzld.ffmpeg;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import com.tzld.ffmpeg.interceptor.CrosDomainAllowInterceptor;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.web.servlet.ServletComponentScan;
+import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
+import org.springframework.cloud.openfeign.EnableFeignClients;
+import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@SpringBootApplication
+@ServletComponentScan("com.tzld.ffmpeg.controller")
+@EnableDiscoveryClient
+@EnableFeignClients
+public class Application implements WebMvcConfigurer {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(Application.class);
+
+    public static void main(String[] args) {
+        SpringApplication.run(Application.class, args);
+        LOGGER.info("ffmpeg-server Start Success");
+    }
+
+    @Override
+    public void addInterceptors(InterceptorRegistry registry) {
+        registry.addInterceptor(new CrosDomainAllowInterceptor()).addPathPatterns("/**");
+    }
+}

src/main/java/com/tzld/ffmpeg/annotation/NoRequestLog.java

@@ -0,0 +1,15 @@
+package com.tzld.ffmpeg.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 请求日志排除注解
+ *
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface NoRequestLog {
+}

src/main/java/com/tzld/ffmpeg/aop/LogRequestAop.java

@@ -0,0 +1,159 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright © 2021 xrv <xrg@live.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.tzld.ffmpeg.aop;
+
+import com.alibaba.fastjson.JSON;
+import com.google.common.base.Strings;
+import com.tzld.commons.aliyun.log.AliyunLogManager;
+import com.tzld.ffmpeg.util.IpUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.annotation.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.slf4j.MDC;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+import javax.servlet.http.HttpServletRequest;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * 请求日志记录
+ *
+ * @author ehlxr
+ * @since 2021-12-14 14:03.
+ */
+@Aspect
+@Component
+public class LogRequestAop {
+    private static final Logger log = LoggerFactory.getLogger(LogRequestAop.class);
+
+    private final AliyunLogManager aliyunLogManager;
+    /**
+     * aliyun log 配置
+     */
+    @Value("${aliyun.log.project:}")
+    private String projcet;
+    @Value("${aliyun.log.logstore.request:request-log}")
+    private String logStore;
+    @Value("${aliyun.log.topic:}")
+    private String topic;
+
+    public static String LOG_TRACE_ID = "logTraceId";
+    private String REQUEST_START_TIME = "request_start_time";
+
+    @Autowired
+    public LogRequestAop(AliyunLogManager aliyunLogManager) {
+        this.aliyunLogManager = aliyunLogManager;
+    }
+
+    /**
+     * 切入点
+     */
+    @Pointcut("execution(public * com.tzld.ffmpeg.controller..*(..)) " +
+            "&& !@annotation(com.tzld.ffmpeg.annotation.NoRequestLog)")
+    public void requestLog() {
+    }
+
+    /**
+     * 前置操作
+     */
+    @Before("requestLog()")
+    public void beforeLog() {
+        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
+        HttpServletRequest request = Objects.requireNonNull(attributes).getRequest();
+
+        request.setAttribute(REQUEST_START_TIME, System.currentTimeMillis());
+    }
+
+    /**
+     * 后置操作
+     */
+    @AfterReturning(pointcut = "requestLog()", returning = "returnValue")
+    public void afterReturning(JoinPoint point, Object returnValue) {
+        logRecord(point, JSON.toJSONString(returnValue));
+    }
+
+    @AfterThrowing(pointcut = "requestLog()", throwing = "ex")
+    public void afterThrowing(JoinPoint point, Exception ex) {
+        logRecord(point, ex.toString());
+    }
+
+    private void logRecord(JoinPoint point, String message) {
+        try {
+            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
+            HttpServletRequest request = Objects.requireNonNull(attributes).getRequest();
+
+            Long startTime = (Long) request.getAttribute(REQUEST_START_TIME);
+            if (Objects.isNull(startTime)) {
+                return;
+            }
+
+            String query = request.getQueryString();
+            String uri = request.getRequestURI();
+
+            Map<String, Object> logMap = new HashMap<>(8);
+            String url = Strings.isNullOrEmpty(query) ? uri : uri + "?" + query;
+            if (StringUtils.isNotBlank(url) && url.contains("/test")) {
+                return;
+            }
+            logMap.put("url", url);
+            logMap.put("method", request.getMethod());
+            logMap.put("header", getHeaders(request));
+            logMap.put("elapsedTime", String.valueOf(System.currentTimeMillis() - startTime));
+            logMap.put("clientIp", IpUtil.getIpAddr(request));
+            logMap.put("requestBody", getRequestBody(point.getArgs()));
+            logMap.put(LOG_TRACE_ID, Strings.nullToEmpty(MDC.get(LOG_TRACE_ID)));
+            logMap.put("responseBody", message);
+            aliyunLogManager.sendLog(projcet, logStore, topic, logMap);
+        } catch (Exception e) {
+            log.error("log report request error", e);
+        }
+    }
+
+    private Object getRequestBody(Object[] args) {
+        try {
+            return JSON.toJSONString(args[0]);
+        } catch (Exception e) {
+            return args;
+        }
+    }
+
+    private String getHeaders(HttpServletRequest request) {
+        return Collections.list(request.getHeaderNames())
+                .stream()
+                .collect(Collectors.toMap(
+                        name -> name,
+                        request::getHeader)).toString();
+    }
+}

src/main/java/com/tzld/ffmpeg/common/Constant.java

@@ -0,0 +1,44 @@
+package com.tzld.ffmpeg.common;
+
+/**
+ * 常量
+ *
+ */
+public class Constant {
+
+    public static final Integer INTEGER_TRUE = 1;
+    public static final Integer INTEGER_FALSE = 0;
+
+    public static final String STRING_TRUE = "1";
+    public static final String STRING_FALSE = "0";
+
+    public static final String PRODUCE_INPUT_OUTPUT_JOIN_SYMBOL = "、";
+
+    public static final String WX_COMPONENT_TOKEN_KEY = "wechat_component_token";
+
+    public static final String COMPONENT_ACCESS_TOKEN = "componentAccessToken";
+
+    public static final String COMPONENT_VERIFY_TICKET = "componentVerifyTicket";
+
+    public static final String COMPONENT_ACCESS_TOKEN_UPDATE_TIMESTAMP = "accessTokenUpdateTimestamp";
+
+    public static final String UUID_RELATE_PRE_AUTHCODE_REDIS_KEY_PREFIX = "uidauthcode:";
+
+    /**
+     * 一小时的毫秒数
+     */
+    public static final long HOUR_MILLISECONDS_TIMESTAMP = 3600000L;
+    /**
+     * 一秒钟的毫秒数
+     */
+    public static final long SECOND_MILLISECONDS_TIMESTAMP = 1000L;
+    /**
+     * 一天的毫秒数
+     */
+    public static final long DAY_MILLISECONDS_TIMESTAMP = 86400000L;
+    /**
+     * 一分鐘的毫秒數
+     */
+    public static final long MINUTE_MILLISECONDS_TIMESTAMP = 60000L;
+
+}

src/main/java/com/tzld/ffmpeg/common/LoghubAppender.java

@@ -0,0 +1,361 @@
+package com.tzld.ffmpeg.common;
+
+import ch.qos.logback.classic.spi.IThrowableProxy;
+import ch.qos.logback.classic.spi.LoggingEvent;
+import ch.qos.logback.classic.spi.StackTraceElementProxy;
+import ch.qos.logback.classic.spi.ThrowableProxyUtil;
+import ch.qos.logback.core.CoreConstants;
+import ch.qos.logback.core.UnsynchronizedAppenderBase;
+import ch.qos.logback.core.encoder.Encoder;
+import com.aliyun.openservices.aliyun.log.producer.LogProducer;
+import com.aliyun.openservices.aliyun.log.producer.Producer;
+import com.aliyun.openservices.aliyun.log.producer.ProducerConfig;
+import com.aliyun.openservices.aliyun.log.producer.ProjectConfig;
+import com.aliyun.openservices.aliyun.log.producer.errors.ProducerException;
+import com.aliyun.openservices.log.common.LogItem;
+import org.joda.time.DateTime;
+import org.joda.time.DateTimeZone;
+import org.joda.time.format.DateTimeFormat;
+import org.joda.time.format.DateTimeFormatter;
+
+import java.time.Instant;
+import java.time.ZoneId;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+public class LoghubAppender<E> extends UnsynchronizedAppenderBase<E> {
+    private String project;
+    private String endpoint;
+    private String accessKeyId;
+    private String accessKeySecret;
+    private String userAgent = "logback";
+    protected Encoder<E> encoder;
+    protected ProducerConfig producerConfig = new ProducerConfig();
+    protected ProjectConfig projectConfig;
+    protected Producer producer;
+    protected String logStore;
+    protected String topic = "";
+    protected String source = "";
+    protected String timeZone = "UTC";
+    protected String timeFormat = "yyyy-MM-dd'T'HH:mmZ";
+    protected DateTimeFormatter formatter;
+    protected java.time.format.DateTimeFormatter formatter1;
+    private String mdcFields;
+
+    public LoghubAppender() {
+    }
+
+    public void start() {
+        try {
+            this.doStart();
+        } catch (Exception var2) {
+            this.addError("Failed to start LoghubAppender.", var2);
+        }
+
+    }
+
+    private void doStart() {
+        try {
+            this.formatter = DateTimeFormat.forPattern(this.timeFormat).withZone(DateTimeZone.forID(this.timeZone));
+        } catch (Exception var2) {
+            this.formatter1 = java.time.format.DateTimeFormatter.ofPattern(this.timeFormat).withZone(ZoneId.of(this.timeZone));
+        }
+
+        this.producer = this.createProducer();
+        super.start();
+    }
+
+    public Producer createProducer() {
+        this.projectConfig = this.buildProjectConfig();
+        Producer producer = new LogProducer(this.producerConfig);
+        producer.putProjectConfig(this.projectConfig);
+        return producer;
+    }
+
+    private ProjectConfig buildProjectConfig() {
+        return new ProjectConfig(this.project, this.endpoint, this.accessKeyId, this.accessKeySecret, (String) null, this.userAgent);
+    }
+
+    public void stop() {
+        try {
+            this.doStop();
+        } catch (Exception var2) {
+            this.addError("Failed to stop LoghubAppender.", var2);
+        }
+
+    }
+
+    private void doStop() throws InterruptedException, ProducerException {
+        if (this.isStarted()) {
+            super.stop();
+            this.producer.close();
+        }
+    }
+
+    public void append(E eventObject) {
+        try {
+            this.appendEvent(eventObject);
+        } catch (Exception var3) {
+            this.addError("Failed to append event.", var3);
+        }
+    }
+
+    private void appendEvent(E eventObject) {
+        if (!(eventObject instanceof LoggingEvent)) {
+            return;
+        }
+        LoggingEvent event = (LoggingEvent) eventObject;
+        if (event.getMarker() == null) {
+            appendPlainEvent(eventObject);
+        }
+    }
+
+    private void appendPlainEvent(E eventObject) {
+        LoggingEvent event = (LoggingEvent) eventObject;
+        List<LogItem> logItems = new ArrayList();
+        LogItem item = new LogItem();
+        logItems.add(item);
+        item.SetTime((int) (event.getTimeStamp() / 1000L));
+        if (this.formatter != null) {
+            DateTime dateTime = new DateTime(event.getTimeStamp());
+            item.PushBack("time", dateTime.toString(this.formatter));
+        } else {
+            Instant instant = Instant.ofEpochMilli(event.getTimeStamp());
+            item.PushBack("time", this.formatter1.format(instant));
+        }
+
+        item.PushBack("level", event.getLevel().toString());
+        item.PushBack("thread", event.getThreadName());
+        StackTraceElement[] caller = event.getCallerData();
+        if (caller != null && caller.length > 0) {
+            item.PushBack("location", caller[0].toString());
+        }
+
+        String message = event.getFormattedMessage();
+        item.PushBack("message", message);
+        IThrowableProxy iThrowableProxy = event.getThrowableProxy();
+        if (iThrowableProxy != null) {
+            String throwable = this.getExceptionInfo(iThrowableProxy);
+            throwable = throwable + this.fullDump(event.getThrowableProxy().getStackTraceElementProxyArray());
+            item.PushBack("throwable", throwable);
+        }
+
+        if (this.encoder != null) {
+            item.PushBack("log", new String(this.encoder.encode(eventObject)));
+        }
+
+        Optional.ofNullable(this.mdcFields).ifPresent((f) -> {
+            event.getMDCPropertyMap().entrySet().stream().filter((v) -> {
+                return Arrays.stream(f.split(",")).anyMatch((i) -> {
+                    return i.equals(v.getKey());
+                });
+            }).forEach((map) -> {
+                item.PushBack((String) map.getKey(), (String) map.getValue());
+            });
+        });
+
+        try {
+            this.producer.send(this.projectConfig.getProject(), this.logStore, this.topic, this.source, logItems,
+                    new LoghubAppenderCallback(this, this.projectConfig.getProject(), this.logStore,
+                            this.topic, this.source, logItems));
+        } catch (Exception var9) {
+            this.addError("Failed to send log, project=" + this.project + ", logStore=" + this.logStore + ", topic=" + this.topic + ", source=" + this.source + ", logItem=" + logItems, var9);
+        }
+    }
+
+    public String getTimeFormat() {
+        return this.timeFormat;
+    }
+
+    public void setTimeFormat(String timeFormat) {
+        this.timeFormat = timeFormat;
+    }
+
+    private String getExceptionInfo(IThrowableProxy iThrowableProxy) {
+        String s = iThrowableProxy.getClassName();
+        String message = iThrowableProxy.getMessage();
+        return message != null ? s + ": " + message : s;
+    }
+
+    private String fullDump(StackTraceElementProxy[] stackTraceElementProxyArray) {
+        StringBuilder builder = new StringBuilder();
+        StackTraceElementProxy[] var3 = stackTraceElementProxyArray;
+        int var4 = stackTraceElementProxyArray.length;
+
+        for (int var5 = 0; var5 < var4; ++var5) {
+            StackTraceElementProxy step = var3[var5];
+            builder.append(CoreConstants.LINE_SEPARATOR);
+            String string = step.toString();
+            builder.append('\t').append(string);
+            ThrowableProxyUtil.subjoinPackagingData(builder, step);
+        }
+
+        return builder.toString();
+    }
+
+    public String getLogStore() {
+        return this.logStore;
+    }
+
+    public void setLogStore(String logStore) {
+        this.logStore = logStore;
+    }
+
+    public String getTopic() {
+        return this.topic;
+    }
+
+    public void setTopic(String topic) {
+        this.topic = topic;
+    }
+
+    public String getSource() {
+        return this.source;
+    }
+
+    public void setSource(String source) {
+        this.source = source;
+    }
+
+    public String getTimeZone() {
+        return this.timeZone;
+    }
+
+    public void setTimeZone(String timeZone) {
+        this.timeZone = timeZone;
+    }
+
+    public String getProject() {
+        return this.project;
+    }
+
+    public void setProject(String project) {
+        this.project = project;
+    }
+
+    public String getEndpoint() {
+        return this.endpoint;
+    }
+
+    public void setEndpoint(String endpoint) {
+        this.endpoint = endpoint;
+    }
+
+    public String getAccessKeyId() {
+        return this.accessKeyId;
+    }
+
+    public void setAccessKeyId(String accessKeyId) {
+        this.accessKeyId = accessKeyId;
+    }
+
+    public String getAccessKeySecret() {
+        return this.accessKeySecret;
+    }
+
+    public void setAccessKeySecret(String accessKeySecret) {
+        this.accessKeySecret = accessKeySecret;
+    }
+
+    public String getUserAgent() {
+        return this.userAgent;
+    }
+
+    public void setUserAgent(String userAgent) {
+        this.userAgent = userAgent;
+    }
+
+    public int getTotalSizeInBytes() {
+        return this.producerConfig.getTotalSizeInBytes();
+    }
+
+    public void setTotalSizeInBytes(int totalSizeInBytes) {
+        this.producerConfig.setTotalSizeInBytes(totalSizeInBytes);
+    }
+
+    public long getMaxBlockMs() {
+        return this.producerConfig.getMaxBlockMs();
+    }
+
+    public void setMaxBlockMs(long maxBlockMs) {
+        this.producerConfig.setMaxBlockMs(maxBlockMs);
+    }
+
+    public int getIoThreadCount() {
+        return this.producerConfig.getIoThreadCount();
+    }
+
+    public void setIoThreadCount(int ioThreadCount) {
+        this.producerConfig.setIoThreadCount(ioThreadCount);
+    }
+
+    public int getBatchSizeThresholdInBytes() {
+        return this.producerConfig.getBatchSizeThresholdInBytes();
+    }
+
+    public void setBatchSizeThresholdInBytes(int batchSizeThresholdInBytes) {
+        this.producerConfig.setBatchSizeThresholdInBytes(batchSizeThresholdInBytes);
+    }
+
+    public int getBatchCountThreshold() {
+        return this.producerConfig.getBatchCountThreshold();
+    }
+
+    public void setBatchCountThreshold(int batchCountThreshold) {
+        this.producerConfig.setBatchCountThreshold(batchCountThreshold);
+    }
+
+    public int getLingerMs() {
+        return this.producerConfig.getLingerMs();
+    }
+
+    public void setLingerMs(int lingerMs) {
+        this.producerConfig.setLingerMs(lingerMs);
+    }
+
+    public int getRetries() {
+        return this.producerConfig.getRetries();
+    }
+
+    public void setRetries(int retries) {
+        this.producerConfig.setRetries(retries);
+    }
+
+    public int getMaxReservedAttempts() {
+        return this.producerConfig.getMaxReservedAttempts();
+    }
+
+    public void setMaxReservedAttempts(int maxReservedAttempts) {
+        this.producerConfig.setMaxReservedAttempts(maxReservedAttempts);
+    }
+
+    public long getBaseRetryBackoffMs() {
+        return this.producerConfig.getBaseRetryBackoffMs();
+    }
+
+    public void setBaseRetryBackoffMs(long baseRetryBackoffMs) {
+        this.producerConfig.setBaseRetryBackoffMs(baseRetryBackoffMs);
+    }
+
+    public long getMaxRetryBackoffMs() {
+        return this.producerConfig.getMaxRetryBackoffMs();
+    }
+
+    public void setMaxRetryBackoffMs(long maxRetryBackoffMs) {
+        this.producerConfig.setMaxRetryBackoffMs(maxRetryBackoffMs);
+    }
+
+    public Encoder<E> getEncoder() {
+        return this.encoder;
+    }
+
+    public void setEncoder(Encoder<E> encoder) {
+        this.encoder = encoder;
+    }
+
+    public void setMdcFields(String mdcFields) {
+        this.mdcFields = mdcFields;
+    }
+}

src/main/java/com/tzld/ffmpeg/common/LoghubAppenderCallback.java

@@ -0,0 +1,34 @@
+package com.tzld.ffmpeg.common;
+
+
+import com.aliyun.openservices.aliyun.log.producer.Callback;
+import com.aliyun.openservices.aliyun.log.producer.Result;
+import com.aliyun.openservices.log.common.LogItem;
+
+import java.util.List;
+
+public class LoghubAppenderCallback<E> implements Callback {
+    protected LoghubAppender<E> loghubAppender;
+    protected String project;
+    protected String logstore;
+    protected String topic;
+    protected String source;
+    protected List<LogItem> logItems;
+
+    public LoghubAppenderCallback(LoghubAppender<E> loghubAppender, String project, String logstore,
+                                  String topic, String source, List<LogItem> logItems) {
+        this.loghubAppender = loghubAppender;
+        this.project = project;
+        this.logstore = logstore;
+        this.topic = topic;
+        this.source = source;
+        this.logItems = logItems;
+    }
+
+    public void onCompletion(Result result) {
+        if (!result.isSuccessful()) {
+            this.loghubAppender.addError("Failed to send log, project=" + this.project + ", logStore=" + this.logstore + ", topic=" + this.topic + ", source=" + this.source + ", logItem=" + this.logItems + ", errorCode=" + result.getErrorCode() + ", errorMessage=" + result.getErrorMessage());
+        }
+
+    }
+}

src/main/java/com/tzld/ffmpeg/common/enums/EnumUploadFileType.java

@@ -0,0 +1,30 @@
+package com.tzld.ffmpeg.common.enums;
+
+public enum EnumUploadFileType {
+	PICTURE(1,"1"),
+	VIDEO(2,"2"),
+	VOICE(3,"3"),
+	FILE(4,"4"),
+	GIF(5,"5"),
+	SUBTITLE(6,"6"),
+	;
+
+	private Integer intType;
+	private String strType;
+	EnumUploadFileType(Integer intType, String strType){
+		this.intType = intType;
+		this.strType = strType;
+	}
+	public Integer getIntType() {
+		return intType;
+	}
+	public void setIntType(Integer intType) {
+		this.intType = intType;
+	}
+	public String getStrType() {
+		return strType;
+	}
+	public void setStrType(String strType) {
+		this.strType = strType;
+	}
+}

src/main/java/com/tzld/ffmpeg/common/enums/ExceptionEnum.java

@@ -0,0 +1,39 @@
+package com.tzld.ffmpeg.common.enums;
+
+/**
+ * 异常枚举
+ * 通用 code三位负整数
+ * 业务 code四位正整数，其中第一位代表功能模块
+ */
+
+public enum ExceptionEnum {
+    // 通用code为三位负整数
+    SYSTEM_ERROR(-101, "系统错误"),
+    DATA_ERROR(-102, "数据异常,请联系管理员"),
+    PARAM_ERROR(-103, "参数不对"),
+    CANNOT_GET_LOCK(-104, "无法获取锁"),
+    FLOW_CONTROL(-105, "flow control"),
+    RATE_LIMIT_EXCEEDED(-106, "重复操作过于频繁"),
+    TOKEN_NOTEXIST(-107, "访问凭证不存在"),
+    INSUFFICIENT_PERMISSIONS(-108, "permission denied"),
+    PAGE_NUM_AND_SIZE_REQUIRED(-109, "page num/size required"),
+    ILLEGAL_OPERATION(-110, "illegal operation"),
+
+    ;
+    private int code;
+    private String msg;
+
+    public int getCode() {
+        return code;
+    }
+
+
+    public String getMsg() {
+        return msg;
+    }
+
+    ExceptionEnum(int code, String msg) {
+        this.code = code;
+        this.msg = msg;
+    }
+}

src/main/java/com/tzld/ffmpeg/config/AliOssConfig.java

@@ -0,0 +1,386 @@
+package com.tzld.ffmpeg.config;
+
+import com.aliyun.oss.ClientConfiguration;
+import com.aliyun.oss.OSSClient;
+import com.aliyuncs.DefaultAcsClient;
+import com.aliyuncs.IAcsClient;
+import com.aliyuncs.profile.DefaultProfile;
+import com.tzld.ffmpeg.model.vo.PolicyDetailVO;
+import com.tzld.ffmpeg.util.AliOssFileTool;
+import com.tzld.ffmpeg.util.PropertiesUtils;
+import org.apache.commons.lang.StringUtils;
+import org.apache.log4j.Logger;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+
+import javax.annotation.PostConstruct;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+
+/**
+ * @author zhaoyuchun
+ */
+@Configuration
+public class AliOssConfig {
+	/** 图片服务域名 **/
+	// public String picEndPoint;
+	/** 对象存储域名 **/
+	private static String ossEndPoint;
+	/** 阿里云accesskeyId **/
+	private static String accessKeyId;
+	/** 过期时间，单位秒 **/
+	private static long expiration;
+	/** 阿里云accessKeySecret **/
+	private static String accessKeySecret;
+	/** 文件系统配置文件地址 **/
+	public String configPath;
+	private static Boolean needPress;
+	private static String projectName;
+	private static String videoEndPoint;
+	private static String internalEndPoint;
+	private static OSSClient ossClient;
+	private static OSSClient priClient;
+	private static OSSClient videoClient;
+	private static OSSClient internalOssClient;
+
+	private static String snapshotLocation;
+	private static OSSClient ossReadOnlyClient;
+	private static IAcsClient mAcsClient;
+
+	private static DefaultAcsClient defaultAcsClient;
+	public static final String PIPELINEID = "abe6a0b9b9334858913eb416974485d2";
+	public static final String MTS_REGION = "cn-hangzhou";
+	public static final String OSS_REGION = "oss-cn-hangzhou";
+	private static PolicyDetailVO policyDetail;
+	static {
+		policyDetail = new PolicyDetailVO();
+		policyDetail.setVersion("1");
+		List<PolicyDetailVO.PolicyVO> statement = new ArrayList<PolicyDetailVO.PolicyVO>();
+		PolicyDetailVO.PolicyVO policy = new PolicyDetailVO.PolicyVO();
+		List<String> action = new ArrayList<String>();
+		List<String> resource = new ArrayList<String>();
+		action.add("oss:PutObject");
+		action.add("oss:AbortMultipartUpload");
+		action.add("oss:ListParts");
+		action.add("oss:AbortMultipartUpload");
+		action.add("oss:ListObjects");
+		resource.add("*");
+		policy.setEffect("Allow");
+		policy.setAction(action);
+		policy.setResource(resource);
+		statement.add(policy);
+		policyDetail.setStatement(statement);
+
+	}
+
+
+	public static OSSClient getVideoClient() {
+		return videoClient;
+	}
+
+	public void setVideoClient(OSSClient videoClient) {
+		AliOssConfig.videoClient = videoClient;
+	}
+
+	public static String cdnDomain;
+	public static String imgDomain;
+	public static String videoDomain;
+	public static String uploadDomain;
+	public static String lvvideoDomain;
+	public static String pubBucket;
+	public static String priBucket;
+	public static String priEndPoint;
+	public static HashMap<String, String> bucketes = new HashMap<String, String>();
+	private static Logger logger = Logger.getLogger(AliOssFileTool.class);
+	public static String SUFFIX = "https://";
+	private String tmpStr;
+	@PostConstruct
+	public void init() throws Exception {
+		logger.info("初始化oss参数");
+		try {
+			setOssEndPoint(ossEndPoint);
+			setProjectName(projectName);
+			setExpiration(Long.valueOf(expiration));
+			setVideoEndPoint(videoEndPoint);
+			setAccessKeyId(accessKeyId);
+			setAccessKeySecret(accessKeySecret);
+			setCdnDomain(cdnDomain);
+			setImgDomain(imgDomain);
+			setVideoDomain(videoDomain);
+			setUploadDomain(uploadDomain);
+			setInternalEndPoint(internalEndPoint);
+			setPubBucket(pubBucket);
+			try{
+				String[] buckets = pubBucket.split(",");
+				for (String bucket : buckets) {
+					String[] bucketParms = bucket.split(":");
+					String bucketKey = bucketParms[0];
+					String bucketName = bucketParms[1];
+					AliOssConfig.bucketes.put(bucketKey, bucketName);
+				}
+			}catch(Exception e){
+				e.printStackTrace();
+			}
+			setPriBucket(priBucket);
+			String[] buckets = priBucket.split(",");
+			for (String bucket : buckets) {
+				String[] bucketParms = bucket.split(":");
+				String bucketKey = bucketParms[0];
+				String bucketName = bucketParms[1];
+				AliOssConfig.bucketes.put(bucketKey, bucketName);
+			}
+			setNeedPress(needPress);
+			setLvvideoDomain(lvvideoDomain);
+			setpriEndPoint(priEndPoint);
+			setSnapshotLocation("");
+
+			setOssClient(new OSSClient(SUFFIX + ossEndPoint, accessKeyId, accessKeySecret));
+			setInternalOssClient(new OSSClient(SUFFIX + internalEndPoint, accessKeyId, accessKeySecret));
+			setPriClient(new OSSClient(SUFFIX + priEndPoint, accessKeyId, accessKeySecret));
+			setVideoClient(new OSSClient(SUFFIX + videoEndPoint, accessKeyId, accessKeySecret));
+			DefaultProfile profile = DefaultProfile.getProfile("cn-hangzhou", accessKeyId, accessKeySecret);
+			setDefaultAcsClient(new DefaultAcsClient(profile));
+		} catch (Exception e) {
+			logger.error("配置文件读取失败");
+			throw e;
+		}
+
+	}
+	@Value("${oss.ffmpeg.priEndPoint}")
+	public void setpriEndPoint(String priEndPoint) {
+		AliOssConfig.priEndPoint = priEndPoint;
+	}
+
+	public static OSSClient getOssReadOnlyClient() {
+		if (AliOssConfig.ossReadOnlyClient == null) {
+			ClientConfiguration conf = new ClientConfiguration();
+			// 设置OSSClient允许打开的最大HTTP连接数，默认为1024个。
+			conf.setMaxConnections(500);
+			// 设置Socket层传输数据的超时时间，默认为50000毫秒。
+			conf.setSocketTimeout(40000);
+			// 设置建立连接的超时时间，默认为50000毫秒。
+			conf.setConnectionTimeout(10000);
+			// 设置从连接池中获取连接的超时时间（单位：毫秒），默认不超时。
+			conf.setConnectionRequestTimeout(1000);
+			// 设置连接空闲超时时间。超时则关闭连接，默认为60000毫秒。
+			conf.setIdleConnectionTime(10000);
+			// 设置失败请求重试次数，默认为3次。
+			conf.setMaxErrorRetry(5);
+			AliOssConfig.ossReadOnlyClient = new OSSClient(SUFFIX + getOssEndPoint(), 
+					PropertiesUtils.getReadOnlyAccessKeyId(),
+					PropertiesUtils.getReadOnlyAccessKeySecret(),
+					conf );
+		}
+		return AliOssConfig.ossReadOnlyClient;
+	}
+	@Value("${oss.ffmpeg.internal.endPoint}")
+	public void setInternalEndPoint(String internalEndPoint) {
+		AliOssConfig.internalEndPoint = internalEndPoint;
+	}
+
+	public static String getInternalEndPoint() {
+		return internalEndPoint;
+	}
+	public static String getBucket(String key) {
+		String bucket = AliOssConfig.bucketes.get(key);
+		if (StringUtils.isEmpty(bucket)) {
+			logger.error(String.format("bucket key[%s]不存在", key));
+		}
+		return bucket;
+	}
+
+	public static String getSnapshotLocation() {
+		return snapshotLocation;
+	}
+
+	public void setSnapshotLocation(String snapshotLocation ) {
+		AliOssConfig.snapshotLocation = snapshotLocation;
+	}
+	
+	public static String getProjectName() {
+		return projectName;
+	}
+
+	@Value("${oss.ffmpeg.projectName}")
+	public void setProjectName(String projectName) {
+		AliOssConfig.projectName = projectName;
+	}
+
+
+	public static OSSClient getOssClient() {
+		return ossClient;
+	}
+
+	public void setOssClient(OSSClient ossClient) {
+		AliOssConfig.ossClient = ossClient;
+	}
+
+	public static OSSClient getInternalOssClient() {
+		return internalOssClient;
+	}
+
+	public void setInternalOssClient(OSSClient internalOssClient) {
+		AliOssConfig.internalOssClient = internalOssClient;
+	}
+
+	public static String getOssEndPoint() {
+		return ossEndPoint;
+	}
+
+	@Value("${oss.ffmpeg.ossEndPoint}")
+	public void setOssEndPoint(String ossEndPoint) {
+		AliOssConfig.ossEndPoint = ossEndPoint;
+	}
+
+	public static String getAccessKeyId() {
+		return accessKeyId;
+	}
+	@Value("${oss.ffmpeg.accessKey}")
+	public void setAccessKeyId(String accessKeyId) {
+		AliOssConfig.accessKeyId = accessKeyId;
+	}
+
+
+
+	public static String getAccessKeySecret() {
+		return accessKeySecret;
+	}
+	@Value("${oss.ffmpeg.secretKey}")
+	public void setAccessKeySecret(String accessKeySecret) {
+		AliOssConfig.accessKeySecret = accessKeySecret;
+	}
+
+	public String getConfigPath() {
+		return configPath;
+	}
+
+	public void setConfigPath(String configPath) {
+		this.configPath = configPath;
+	}
+
+	public static String getCdnDomain() {
+		return cdnDomain;
+	}
+	@Value("${oss.ffmpeg.cdnDomain}")
+	public void setCdnDomain(String cdnDomain) {
+		AliOssConfig.cdnDomain = cdnDomain;
+	}
+
+	public static String getImgDomain() {
+		return imgDomain;
+	}
+
+	@Value("${oss.ffmpeg.imgDomain}")
+	public void setImgDomain(String imgDomain) {
+		AliOssConfig.imgDomain = imgDomain;
+	}
+	@Value("${oss.ffmpeg.pubBucket}")
+	public void setPubBucket(String pubBucket) {
+		AliOssConfig.pubBucket = pubBucket;
+	}
+	@Value("${oss.ffmpeg.priBucket}")
+	public void setPriBucket(String priBucket) {
+		AliOssConfig.priBucket = priBucket;
+	}
+
+	public static HashMap<String, String> getBucketes() {
+		return bucketes;
+	}
+
+	public void setBucketes(HashMap<String, String> bucketes) {
+		AliOssConfig.bucketes = bucketes;
+	}
+
+
+	public static Boolean getNeedPress() {
+		return needPress;
+	}
+	@Value("${oss.ffmpeg.needPress}")
+	public void setNeedPress(Boolean needPress) {
+		AliOssConfig.needPress = needPress;
+	}
+
+	public static String getVideoDomain() {
+		return videoDomain;
+	}
+	@Value("${oss.ffmpeg.videoDomain}")
+	public void setVideoDomain(String videoDomain) {
+		AliOssConfig.videoDomain = videoDomain;
+	}
+
+	public static String getVideoEndPoint() {
+		return videoEndPoint;
+	}
+	@Value("${oss.ffmpeg.videoEndPoint}")
+	public void setVideoEndPoint(String videoEndPoint) {
+		AliOssConfig.videoEndPoint = videoEndPoint;
+	}
+
+
+	public static long getExpiration() {
+		return expiration;
+	}
+	@Value("${oss.ffmpeg.expiration}")
+	public void setExpiration(long expiration) {
+		AliOssConfig.expiration = expiration;
+	}
+
+	public static String getUploadDomain() {
+		return uploadDomain;
+	}
+	@Value("${cdn.upload.domain}")
+	public void setUploadDomain(String uploadDomain) {
+		AliOssConfig.uploadDomain = uploadDomain;
+	}
+
+	public static PolicyDetailVO getPolicyDetail() {
+		return policyDetail;
+	}
+
+	public void setPolicyDetail(PolicyDetailVO policyDetail) {
+		AliOssConfig.policyDetail = policyDetail;
+	}
+
+	public static OSSClient getPriClient() {
+		return priClient;
+	}
+
+	public void setPriClient(OSSClient priClient) {
+		AliOssConfig.priClient = priClient;
+	}
+
+	public static DefaultAcsClient getDefaultAcsClient() {
+		return defaultAcsClient;
+	}
+
+	public void setDefaultAcsClient(DefaultAcsClient defaultAcsClient) {
+		AliOssConfig.defaultAcsClient = defaultAcsClient;
+	}
+
+	public static String getLvvideoDomain() {
+		return lvvideoDomain;
+	}
+	@Value("${oss.ffmpeg.lvvideoDomain}")
+	public void setLvvideoDomain(String lvvideoDomain) {
+		AliOssConfig.lvvideoDomain = lvvideoDomain;
+	}
+	
+	public static OSSClient getShangHaiInternalOssClient() {
+		return new OSSClient(SUFFIX + "oss-cn-shanghai.aliyuncs.com", accessKeyId, accessKeySecret);
+	} 
+	
+	public static IAcsClient getIAcsClient() {
+		if (AliOssConfig.mAcsClient == null) {
+			DefaultProfile profile = DefaultProfile.getProfile(getMpsRegionId(), // 地域ID
+					getAccessKeyId(), // RAM账号的AccessKey ID
+					getAccessKeySecret()); // RAM账号Access Key Secret
+			mAcsClient = new DefaultAcsClient(profile);
+		}
+		return AliOssConfig.mAcsClient;
+	}
+	public static String getMpsRegionId() {
+		return PropertiesUtils.getValue("oss.longvideo.transcode.mpsRegionId");
+	}
+}

src/main/java/com/tzld/ffmpeg/config/RedisConfig.java

@@ -0,0 +1,43 @@
+package com.tzld.ffmpeg.config;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.RedisSerializer;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+@Configuration
+public class RedisConfig {
+
+    @Bean
+    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
+        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
+        redisTemplate.setConnectionFactory(redisConnectionFactory);
+        //设置value的序列化方式json
+        redisTemplate.setValueSerializer(redisSerializer());
+        //设置key序列化方式String
+        redisTemplate.setKeySerializer(new StringRedisSerializer());
+        //设置hash key序列化方式String
+        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
+        //设置hash value序列化json
+        redisTemplate.setHashValueSerializer(redisSerializer());
+        redisTemplate.afterPropertiesSet();
+        return redisTemplate;
+    }
+
+    public RedisSerializer<Object> redisSerializer() {
+        //创建JSON序列化器
+        ObjectMapper objectMapper = new ObjectMapper();
+        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
+        //必须设置，否则无法序列化实体类对象
+        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
+        return new GenericJackson2JsonRedisSerializer(objectMapper);
+    }
+
+}

src/main/java/com/tzld/ffmpeg/config/SwaggerConfig.java

@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.tzld.ffmpeg.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+import springfox.documentation.builders.ApiInfoBuilder;
+import springfox.documentation.builders.PathSelectors;
+import springfox.documentation.builders.RequestHandlerSelectors;
+import springfox.documentation.service.ApiInfo;
+import springfox.documentation.spi.DocumentationType;
+import springfox.documentation.spring.web.plugins.Docket;
+import springfox.documentation.swagger2.annotations.EnableSwagger2;
+
+/**
+ * swagger2 配置
+ */
+@Configuration
+@Profile({"dev","test","pre"})
+@EnableSwagger2
+public class SwaggerConfig {
+
+    @Bean
+    public Docket createRestApi() {
+        return new Docket(DocumentationType.SWAGGER_2)
+                .apiInfo(apiInfo())
+                .select()
+                .apis(RequestHandlerSelectors.basePackage("com.tzld.ffmpeg.controller"))
+                .paths(PathSelectors.any())
+                .build();
+    }
+
+    private ApiInfo apiInfo() {
+        return new ApiInfoBuilder()
+                .title("ffmpeg server swagger api")
+                .description("ffmpeg server swagger api")
+                .version("1.0")
+                .build();
+    }
+}

src/main/java/com/tzld/ffmpeg/config/db/FFmpegDBConfig.java

@@ -0,0 +1,57 @@
+package com.tzld.ffmpeg.config.db;
+
+import com.zaxxer.hikari.HikariDataSource;
+import org.apache.ibatis.session.SqlSessionFactory;
+import org.mybatis.spring.SqlSessionFactoryBean;
+import org.mybatis.spring.boot.autoconfigure.MybatisProperties;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
+import org.springframework.jdbc.datasource.DataSourceTransactionManager;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+import javax.sql.DataSource;
+
+@Configuration
+@EnableTransactionManagement
+public class FFmpegDBConfig {
+
+    // 1. 配置 ffmpeg 数据源
+    @Primary
+    @Bean(name = "ffmpegDataSource")
+    @ConfigurationProperties(prefix = "spring.datasource.ffmpeg")
+    public DataSource ffmpegDataSource() {
+        return new HikariDataSource(); // 使用 HikariCP 连接池
+    }
+
+    // 2. 配置 ffmpeg 专属 SqlSessionFactory
+    @Primary
+    @Bean(name = "ffmpegSqlSessionFactory")
+    public SqlSessionFactory ffmpegSqlSessionFactory(
+            @Qualifier("ffmpegDataSource") DataSource ffmpegDataSource,
+            MybatisProperties properties) throws Exception {
+        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
+        sessionFactory.setDataSource(ffmpegDataSource); // 关联 ffmpeg 数据源
+        // 关键：指定 ffmpeg 模块的 mapper 文件路径（隔离其他数据源）
+        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
+                .getResources("classpath:mapper/ffmpeg/**/*.xml"));
+        sessionFactory.setTypeAliasesPackage("com.tzld.ffmpeg");
+        sessionFactory.setConfiguration(properties.getConfiguration());
+        return sessionFactory.getObject();
+    }
+
+
+    // 3. 配置 ffmpeg 事务管理器
+    @Primary
+    @Bean(name = "ffmpegTransactionManager")
+    public PlatformTransactionManager ffmpegTransactionManager(
+            @Qualifier("ffmpegDataSource") DataSource ffmpegDataSource) {
+        return new DataSourceTransactionManager(ffmpegDataSource);
+    }
+
+}
+

src/main/java/com/tzld/ffmpeg/config/mybatis/FFmpegMybatisConfig.java

@@ -0,0 +1,19 @@
+package com.tzld.ffmpeg.config.mybatis;
+
+import org.apache.ibatis.session.SqlSessionFactory;
+import org.mybatis.spring.SqlSessionTemplate;
+import org.mybatis.spring.annotation.MapperScan;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@MapperScan(basePackages = "com.tzld.ffmpeg.dao.mapper.ffmpeg",
+        sqlSessionFactoryRef = "ffmpegSqlSessionFactory")
+public class FFmpegMybatisConfig {
+
+    @Bean(name = "ffmpegSqlSessionTemplate")
+    public SqlSessionTemplate ffmpegSqlSessionTemplate(@Qualifier("ffmpegSqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
+        return new SqlSessionTemplate(sqlSessionFactory);
+    }
+}

src/main/java/com/tzld/ffmpeg/controller/FFmpegController.java

@@ -0,0 +1,124 @@
+package com.tzld.ffmpeg.controller;
+
+import com.tzld.ffmpeg.model.CommonResponse;
+import com.tzld.ffmpeg.model.param.*;
+import com.tzld.ffmpeg.service.FFmpegService;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/ffmpeg")
+public class FFmpegController {
+
+    @Autowired
+    FFmpegService fFmpegService;
+
+    @ApiOperation(value = "融合背景视频")
+    @PostMapping("/mergeBgVideo")
+    public CommonResponse<String> mergeBgVideo(@RequestBody MergeBgVideoParam param) {
+        return CommonResponse.success(fFmpegService.mergeBgVideo(param));
+    }
+
+    @ApiOperation(value = "去除背景")
+    @PostMapping("/removeBg")
+    public CommonResponse<String> mergeBgVideo(@RequestBody RemoveBgParam param) {
+        return CommonResponse.success(fFmpegService.removeBg(param));
+    }
+
+    @ApiOperation(value = "视频添加ass字幕")
+    @PostMapping("/videoAddAssSubtitle")
+    public CommonResponse<String> videoAddAssSubtitle(@RequestBody VideoAddAssSubtitleParam param) {
+        return CommonResponse.success(fFmpegService.videoAddAssSubtitle(param));
+    }
+
+    @ApiOperation(value = "视频提取音频")
+    @PostMapping("/extraAudio")
+    public CommonResponse<List<String>> videoExtraAudio(@RequestBody VideoUrlsParam param) {
+        return CommonResponse.success(fFmpegService.videoExtraAudio(param));
+    }
+
+    @ApiOperation(value = "视频截帧-根据时间戳")
+    @PostMapping("/timeExtraFrame")
+    public CommonResponse<String> videoTimeExtraFrame(@RequestBody VideoTimeExtraFrameParam param) {
+        return CommonResponse.success(fFmpegService.videoTimeExtraFrame(param));
+    }
+
+    @ApiOperation(value = "视频片段截取-根据时间范围")
+    @PostMapping("/timeCutVideo")
+    public CommonResponse<String> timeCutVideo(@RequestBody VideoTimeCutParam param) {
+        return CommonResponse.success(fFmpegService.timeCutVideo(param));
+    }
+
+    @ApiOperation(value = "视频提取音频-根据时间范围")
+    @PostMapping("/timeExtraAudio")
+    public CommonResponse<String> timeExtraAudio(@RequestBody VideoTimeCutParam param) {
+        return CommonResponse.success(fFmpegService.timeExtraAudio(param));
+    }
+
+    @ApiOperation(value = "视频音频简单合并")
+    @PostMapping("/media/merge/simple")
+    public CommonResponse<String> mediaSimpleMerge(@RequestBody MediaSimpleMergeParam param) {
+        return CommonResponse.success(fFmpegService.mediaSimpleMerge(param));
+    }
+
+    @ApiOperation(value = "视频贴图")
+    @PostMapping("/videoTexture")
+    public CommonResponse<String> videoTexture(@RequestBody VideoTextureParam param) {
+        return CommonResponse.success(fFmpegService.videoTexture(param));
+    }
+
+    @ApiOperation(value = "获取视频宽高等信息")
+    @PostMapping("/video/info")
+    public CommonResponse<String> videoInfo(@RequestBody VideoInfoParam param) {
+        return CommonResponse.success(fFmpegService.videoInfo(param.getVideoUrl()));
+    }
+
+    @ApiOperation(value = "视频拼接")
+    @PostMapping("/videoConcat")
+    public CommonResponse<String> videoConcat(@RequestBody VideoUrlsParam param) {
+        return CommonResponse.success(fFmpegService.videoConcat(param));
+    }
+
+    @ApiOperation(value = "视频增加片尾")
+    @PostMapping("/videoAddTail")
+    public CommonResponse<String> videoAddTail(@RequestBody VideoAddTailParam param) {
+        return CommonResponse.success(fFmpegService.videoAddTail(param));
+    }
+
+    @ApiOperation(value = "视频转码")
+    @PostMapping("/videoTranscoding")
+    public CommonResponse<String> videoTranscoding(@RequestBody VideoTranscodingParam param) {
+        return CommonResponse.success(fFmpegService.videoTranscoding(param));
+    }
+
+    @ApiOperation(value = "视频添加音频")
+    @PostMapping("/videoAddAudio")
+    public CommonResponse<String> videoAddAudio(@RequestBody VideoAddAudioParam param) {
+        return CommonResponse.success(fFmpegService.videoAddAudio(param));
+    }
+
+    @ApiOperation(value = "音频降噪")
+    @PostMapping("/audioVolume")
+    public CommonResponse<String> audioVolume(@RequestBody AudioVolumeParam param) {
+        return CommonResponse.create(fFmpegService.audioVolume(param));
+    }
+
+    @ApiOperation(value = "音频切割")
+    @PostMapping("/audio/split")
+    public CommonResponse<String> audioSplit(@RequestBody AudioSplitParam param) {
+        return CommonResponse.create(fFmpegService.audioSplit(param));
+    }
+
+    @ApiOperation(value = "命令行执行")
+    @PostMapping("/command")
+    public CommonResponse<String> command(@RequestBody CommandParam param) {
+        return CommonResponse.success(fFmpegService.command(param));
+    }
+
+}

src/main/java/com/tzld/ffmpeg/controller/HealthController.java

@@ -0,0 +1,21 @@
+package com.tzld.ffmpeg.controller;
+
+import com.tzld.ffmpeg.annotation.NoRequestLog;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/")
+public class HealthController {
+
+    /**
+     * 探活
+     * @return
+     */
+    @GetMapping("/healthcheck")
+    @NoRequestLog
+    public String healthcheck() {
+        return "ok";
+    }
+}

src/main/java/com/tzld/ffmpeg/dao/generator/MybatisGeneratorMain.java

@@ -0,0 +1,31 @@
+package com.tzld.ffmpeg.dao.generator;
+
+import org.mybatis.generator.api.MyBatisGenerator;
+import org.mybatis.generator.config.Configuration;
+import org.mybatis.generator.config.xml.ConfigurationParser;
+import org.mybatis.generator.exception.InvalidConfigurationException;
+import org.mybatis.generator.exception.XMLParserException;
+import org.mybatis.generator.internal.DefaultShellCallback;
+
+import java.io.File;
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class MybatisGeneratorMain {
+
+	public static void main(String[] args)
+			throws SQLException, IOException, InterruptedException, InvalidConfigurationException, XMLParserException {
+		List<String> warnings = new ArrayList<String>();
+		boolean overwrite = true;
+		File configFile = new File(MybatisGeneratorMain.class.getResource("/generator/mybatis-ffmpeg-generator-config.xml").getFile());
+
+		ConfigurationParser cp = new ConfigurationParser(warnings);
+		Configuration config = cp.parseConfiguration(configFile);
+		DefaultShellCallback callback = new DefaultShellCallback(overwrite);
+		MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
+		myBatisGenerator.generate(null);
+		System.out.println("generate finish");
+	}
+}

src/main/java/com/tzld/ffmpeg/dao/mapper/ffmpeg/ext/SpiderMapperExt.java

@@ -0,0 +1,8 @@
+package com.tzld.ffmpeg.dao.mapper.ffmpeg.ext;
+
+
+import java.util.List;
+
+public interface SpiderMapperExt {
+
+}

src/main/java/com/tzld/ffmpeg/exception/CommonException.java

@@ -0,0 +1,87 @@
+package com.tzld.ffmpeg.exception;
+
+import com.tzld.ffmpeg.common.enums.ExceptionEnum;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * 通用异常
+ */
+public class CommonException extends RuntimeException {
+
+    /**
+     *
+     */
+    private static final long serialVersionUID = 1L;
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(CommonException.class);
+    /**
+     * 异常
+     */
+    private ExceptionEnum exceptionEnum;
+    /**
+     * 错误码
+     */
+    private int code;
+    /**
+     * 异常信息
+     */
+    private String msg;
+
+
+    public int getCode() {
+        return code;
+    }
+
+    public void setCode(int code) {
+        this.code = code;
+    }
+
+    public String getMsg() {
+        return msg;
+    }
+
+    public void setMsg(String msg) {
+        this.msg = msg;
+    }
+
+    public CommonException(Throwable throwable) {
+        super(throwable);
+    }
+
+    public CommonException(int code, String msg) {
+        super(msg);
+        this.code = code;
+        this.msg = msg;
+    }
+
+    public CommonException(ExceptionEnum exceptionEnum) {
+        super(exceptionEnum.getMsg());
+        this.exceptionEnum = exceptionEnum;
+        this.code = exceptionEnum.getCode();
+        this.msg = exceptionEnum.getMsg();
+    }
+
+
+    public CommonException(int code, String msg, Throwable throwable) {
+        super(msg, throwable);
+        this.code = code;
+        this.msg = msg;
+    }
+
+    public CommonException(ExceptionEnum exceptionEnum, Throwable throwable) {
+        super(exceptionEnum.getMsg(), throwable);
+        this.exceptionEnum = exceptionEnum;
+        this.code = exceptionEnum.getCode();
+        this.msg = exceptionEnum.getMsg();
+    }
+
+
+    @Override
+    public void printStackTrace() {
+        if (exceptionEnum != null) {
+            LOGGER.info("exception code = {}, msg = {}", exceptionEnum.getCode(), exceptionEnum.getMsg());
+        }
+        LOGGER.info("exception code = {}, msg = {}", code, msg);
+    }
+}

src/main/java/com/tzld/ffmpeg/exception/DownloadImageError.java

@@ -0,0 +1,8 @@
+package com.tzld.ffmpeg.exception;
+
+public class DownloadImageError extends Exception{
+
+    public DownloadImageError(String message) {
+        super(message);
+    }
+}

src/main/java/com/tzld/ffmpeg/exception/FFmpegExecuteException.java

@@ -0,0 +1,8 @@
+package com.tzld.ffmpeg.exception;
+
+public class FFmpegExecuteException extends RuntimeException {
+
+    public FFmpegExecuteException(String message) {
+        super(message);
+    }
+}

src/main/java/com/tzld/ffmpeg/exception/LayerException.java

@@ -0,0 +1,8 @@
+package com.tzld.ffmpeg.exception;
+
+public class LayerException extends Exception{
+
+    public LayerException(String message) {
+        super(message);
+    }
+}

src/main/java/com/tzld/ffmpeg/exception/SplicingImageError.java

@@ -0,0 +1,9 @@
+package com.tzld.ffmpeg.exception;
+
+
+public class SplicingImageError extends Exception{
+
+    public SplicingImageError(String message) {
+        super(message);
+    }
+}

src/main/java/com/tzld/ffmpeg/exception/VaryImageException.java

@@ -0,0 +1,8 @@
+package com.tzld.ffmpeg.exception;
+
+public class VaryImageException extends Exception{
+
+    public VaryImageException(String message) {
+        super(message);
+    }
+}

src/main/java/com/tzld/ffmpeg/filter/CustomFilter.java

@@ -0,0 +1,40 @@
+package com.tzld.ffmpeg.filter;
+
+import com.tzld.ffmpeg.aop.LogRequestAop;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.slf4j.MDC;
+import org.springframework.core.annotation.Order;
+
+import javax.servlet.*;
+import javax.servlet.annotation.WebFilter;
+import java.io.IOException;
+import java.util.UUID;
+
+/**
+ * auth filter
+ *
+ */
+@Order(value = 1)
+@WebFilter(filterName = "customFilter", urlPatterns = {"/*"})
+public class CustomFilter implements Filter {
+    private static final Logger log = LoggerFactory.getLogger(CustomFilter.class);
+
+    @Override
+    public void init(FilterConfig filterConfig) {
+        log.info("customFilter init");
+    }
+
+    @Override
+    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
+            throws IOException, ServletException {
+        MDC.put(LogRequestAop.LOG_TRACE_ID, UUID.randomUUID().toString().replaceAll("-", ""));
+        filterChain.doFilter(servletRequest, servletResponse);
+        MDC.remove(LogRequestAop.LOG_TRACE_ID);
+    }
+
+    @Override
+    public void destroy() {
+        log.info("customFilter destroy");
+    }
+}

src/main/java/com/tzld/ffmpeg/handle/GlobalExceptionHandle.java

@@ -0,0 +1,73 @@
+package com.tzld.ffmpeg.handle;
+
+import com.tzld.ffmpeg.common.enums.ExceptionEnum;
+import com.tzld.ffmpeg.exception.CommonException;
+import com.tzld.ffmpeg.model.CommonResponse;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.util.CollectionUtils;
+import org.springframework.validation.BindException;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+
+import javax.servlet.http.HttpServletRequest;
+import java.util.List;
+
+/**
+ * 全局异常处理器
+ */
+
+@RestControllerAdvice
+public class GlobalExceptionHandle {
+
+    private static Logger LOGGER = LoggerFactory.getLogger(GlobalExceptionHandle.class);
+
+    @ExceptionHandler
+    public Object handleException(HttpServletRequest req, Exception exception) throws Exception {
+        String uri = req.getRequestURI();
+        CommonResponse<Object> response = new CommonResponse<Object>();
+        // 业务异常
+        if (exception instanceof CommonException) {
+            CommonException e = (CommonException) exception;
+            response.setCode(e.getCode());
+            response.setMsg(e.getMsg());
+            LOGGER.info("uri:" + uri + "\n" + "CustomException log.", exception);
+        } else if (exception instanceof MethodArgumentNotValidException) {
+            // 参数校验异常
+            MethodArgumentNotValidException e = (MethodArgumentNotValidException) exception;
+            List<ObjectError> errorList = e.getBindingResult().getAllErrors();
+            StringBuilder errorMsg = new StringBuilder();
+            errorMsg.append("|");
+            if (!CollectionUtils.isEmpty(errorList)) {
+                for (ObjectError objectError : errorList) {
+                    errorMsg.append(objectError.getDefaultMessage()).append("|");
+                }
+            }
+            response.setCode(ExceptionEnum.PARAM_ERROR.getCode());
+            response.setMsg(errorMsg.toString());
+            LOGGER.error("uri:" + uri + "\n" + "MethodArgumentNotValidException log.", exception);
+        } else if (exception instanceof BindException) {
+            // 参数绑定异常
+            BindException e = (BindException) exception;
+            List<ObjectError> errorList = e.getBindingResult().getAllErrors();
+            StringBuilder errorMsg = new StringBuilder();
+            errorMsg.append("|");
+            if (!CollectionUtils.isEmpty(errorList)) {
+                for (ObjectError objectError : errorList) {
+                    errorMsg.append(objectError.getDefaultMessage()).append("|");
+                }
+            }
+            response.setCode(ExceptionEnum.PARAM_ERROR.getCode());
+            response.setMsg(errorMsg.toString());
+            LOGGER.error("uri:" + uri + "\n" + "BindException log.", exception);
+        } else {
+            response.setCode(ExceptionEnum.SYSTEM_ERROR.getCode());
+            response.setMsg(ExceptionEnum.SYSTEM_ERROR.getMsg());
+            LOGGER.error("uri:" + uri + "\n" + "unknownException log.", exception);
+        }
+        return response;
+    }
+
+}

src/main/java/com/tzld/ffmpeg/interceptor/CrosDomainAllowInterceptor.java

@@ -0,0 +1,38 @@
+package com.tzld.ffmpeg.interceptor;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.servlet.HandlerInterceptor;
+import org.springframework.web.servlet.ModelAndView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@Component
+public class CrosDomainAllowInterceptor implements HandlerInterceptor {
+
+    @Override
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
+            throws Exception {
+        response.addHeader("Access-Control-Allow-Origin", "*");
+        response.addHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+        response.addHeader("Access-Control-Allow-Headers", "*");
+        if (request.getMethod().equals(RequestMethod.OPTIONS.name())) {
+            response.setStatus(HttpStatus.OK.value());
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
+                           ModelAndView modelAndView) throws Exception {
+    }
+
+    @Override
+    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
+            throws Exception {
+    }
+
+}

src/main/java/com/tzld/ffmpeg/model/CommonResponse.java

@@ -0,0 +1,84 @@
+package com.tzld.ffmpeg.model;
+
+
+import com.tzld.ffmpeg.common.enums.ExceptionEnum;
+
+/**
+ * Common Response
+ */
+public class CommonResponse<T> {
+
+    private static final int SUCCESS_CODE = 0;
+    private static final String SUCCESS_MSG = "success";
+
+    /** 返回状态码，0 表示业务成功 */
+    private int code = 0;
+    /** 返回消息 */
+    private String msg = "success";
+    /** 业务成功时返回数据 */
+    private T data;
+
+    public static <T> CommonResponse<T> success() {
+        CommonResponse<T> commonResponse = new CommonResponse<>();
+        commonResponse.setCode(SUCCESS_CODE);
+        commonResponse.setMsg(SUCCESS_MSG);
+        return commonResponse;
+    }
+
+    public static <T> CommonResponse<T> success(T data) {
+        CommonResponse<T> commonResponse = new CommonResponse<>();
+        commonResponse.setCode(SUCCESS_CODE);
+        commonResponse.setMsg(SUCCESS_MSG);
+        commonResponse.setData(data);
+        return commonResponse;
+    }
+
+    public static <T> CommonResponse<T> create() {
+        return create(SUCCESS_CODE, SUCCESS_MSG, null);
+    }
+
+    public static <T> CommonResponse<T> create(T data) {
+        return create(SUCCESS_CODE, SUCCESS_MSG, data);
+    }
+
+    public static <T> CommonResponse<T> create(int code, String msg) {
+        return create(code, msg, null);
+    }
+
+    public static <T> CommonResponse<T> create(ExceptionEnum exceptionEnum) {
+        return create(exceptionEnum.getCode(), exceptionEnum.getMsg(), null);
+    }
+
+    public static <T> CommonResponse<T> create(int code, String msg, T data) {
+        CommonResponse<T> commonResponse = new CommonResponse<>();
+        commonResponse.setCode(code);
+        commonResponse.setMsg(msg);
+        commonResponse.setData(data);
+        return commonResponse;
+    }
+
+    public int getCode() {
+        return code;
+    }
+
+    public void setCode(int code) {
+        this.code = code;
+    }
+
+    public String getMsg() {
+        return msg;
+    }
+
+    public void setMsg(String msg) {
+        this.msg = msg;
+    }
+
+    public T getData() {
+        return data;
+    }
+
+    public void setData(T data) {
+        this.data = data;
+    }
+
+}

src/main/java/com/tzld/ffmpeg/model/dto/SplicingImageDTO.java

@@ -0,0 +1,16 @@
+package com.tzld.ffmpeg.model.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+import java.awt.image.BufferedImage;
+
+@Getter
+@Setter
+@Accessors(chain = true)
+public class SplicingImageDTO {
+    private BufferedImage image;
+    private Integer width;
+    private Integer height;
+}

src/main/java/com/tzld/ffmpeg/model/dto/ali/AliVoiceResultData.java

@@ -0,0 +1,12 @@
+package com.tzld.ffmpeg.model.dto.ali;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class AliVoiceResultData {
+    private String taskId;
+    private List<AliVoiceResultSentenceData> sentences;
+    private List<AliVoiceResultWordData> words;
+}

src/main/java/com/tzld/ffmpeg/model/dto/ali/AliVoiceResultSentenceData.java

@@ -0,0 +1,14 @@
+package com.tzld.ffmpeg.model.dto.ali;
+
+import lombok.Data;
+
+@Data
+public class AliVoiceResultSentenceData {
+    private Integer ChannelId;
+    private Integer BeginTime;
+    private Integer EndTime;
+    private String Text;
+    private Integer SilenceDuration;
+    private Integer SpeechRate;
+    private Double EmotionValue;
+}

src/main/java/com/tzld/ffmpeg/model/dto/ali/AliVoiceResultWordData.java

@@ -0,0 +1,11 @@
+package com.tzld.ffmpeg.model.dto.ali;
+
+import lombok.Data;
+
+@Data
+public class AliVoiceResultWordData {
+    private Integer ChannelId;
+    private Integer BeginTime;
+    private Integer EndTime;
+    private String Word;
+}

src/main/java/com/tzld/ffmpeg/model/param/AudioSplitParam.java

@@ -0,0 +1,17 @@
+package com.tzld.ffmpeg.model.param;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+@Data
+@Accessors(chain = true)
+public class AudioSplitParam {
+
+    private String audioUrl;
+
+    /**
+     * 间隔时长，按照间隔时长切分时需要
+     */
+    private Integer segmentTime;
+
+}

src/main/java/com/tzld/ffmpeg/model/param/AudioVolumeParam.java

@@ -0,0 +1,13 @@
+package com.tzld.ffmpeg.model.param;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+@Data
+@Accessors(chain = true)
+public class AudioVolumeParam {
+
+    private String audioUrl;
+
+    private Double volume;
+}

src/main/java/com/tzld/ffmpeg/model/param/CommandParam.java

@@ -0,0 +1,13 @@
+package com.tzld.ffmpeg.model.param;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class CommandParam {
+    private String ffmpegCommand;
+    private String outputFile;
+    // video audio image text unknown
+    private String outputType;
+}

src/main/java/com/tzld/ffmpeg/model/param/DiverseSplicingImageParam.java

@@ -0,0 +1,43 @@
+package com.tzld.ffmpeg.model.param;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+@Getter
+@Setter
+@Accessors(chain = true)
+public class DiverseSplicingImageParam {
+    @ApiModelProperty(value = "direction。row、column")
+    private String direction;
+    @ApiModelProperty(value = "链接")
+    private String img;
+    @ApiModelProperty(value = "尺寸")
+    private Size size;
+    @ApiModelProperty(value = "间距")
+    private Integer gap;
+    @ApiModelProperty(value = "裁切位置")
+    private Position position;
+    @ApiModelProperty(value = "children")
+    private List<DiverseSplicingImageParam> children;
+
+    @Getter
+    @Setter
+    public static class Size {
+        private Integer width;
+        private Integer height;
+    }
+
+    @Getter
+    @Setter
+    public static class Position {
+        private BigDecimal top;
+        private BigDecimal bottom;
+        private BigDecimal left;
+        private BigDecimal right;
+    }
+}

src/main/java/com/tzld/ffmpeg/model/param/ExtraVideoSrtParam.java

@@ -0,0 +1,14 @@
+package com.tzld.ffmpeg.model.param;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+
+@Getter
+@Setter
+@Accessors(chain = true)
+public class ExtraVideoSrtParam {
+    private String videoUrl;
+
+}

src/main/java/com/tzld/ffmpeg/model/param/MediaSimpleMergeParam.java

@@ -0,0 +1,15 @@
+package com.tzld.ffmpeg.model.param;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+import java.util.List;
+
+@Getter
+@Setter
+@Accessors(chain = true)
+public class MediaSimpleMergeParam {
+    private List<String> videoUrls;
+    private List<String> audioUrls;
+}

src/main/java/com/tzld/ffmpeg/model/param/MergeBgVideoParam.java

@@ -0,0 +1,14 @@
+package com.tzld.ffmpeg.model.param;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class MergeBgVideoParam {
+    private String mainVideo;
+    private String type;
+    private String bgMedia;
+    // 0x00FF00
+    private String color;
+}

src/main/java/com/tzld/ffmpeg/model/param/RemoveBgParam.java

@@ -0,0 +1,14 @@
+package com.tzld.ffmpeg.model.param;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class RemoveBgParam {
+    // video/image
+    private String mediaType;
+    private String mediaUrl;
+    // 0x00FF00
+    private String color;
+}

src/main/java/com/tzld/ffmpeg/model/param/SimpleSplicingImageParam.java

@@ -0,0 +1,23 @@
+package com.tzld.ffmpeg.model.param;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+@Getter
+@Setter
+@Accessors(chain = true)
+public class SimpleSplicingImageParam {
+    /**
+     * 图片链接
+     */
+    private String url;
+    /**
+     * 自定义图片宽度，默认为原始宽度
+     */
+    private Integer width;
+    /**
+     * 自定义图片高度，默认为原始高度
+     */
+    private Integer height;
+}

src/main/java/com/tzld/ffmpeg/model/param/VideoAddAssSubtitleParam.java

@@ -0,0 +1,11 @@
+package com.tzld.ffmpeg.model.param;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class VideoAddAssSubtitleParam {
+    private String videoUrl;
+    private String assSubtitle;
+}

src/main/java/com/tzld/ffmpeg/model/param/VideoAddAudioParam.java

@@ -0,0 +1,19 @@
+package com.tzld.ffmpeg.model.param;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class VideoAddAudioParam {
+    private String videoUrl;
+    private String audioUrl;
+    // 主时间轴，video/audio
+    private String mainTimeline;
+    // 是否保留视频原声
+    private Boolean keepVideoOriginalSound;
+    // 视频音量 1-100
+    private Integer videoVolume;
+    // 音频音量 1-100
+    private Integer audioVolume;
+}

src/main/java/com/tzld/ffmpeg/model/param/VideoAddTailParam.java

@@ -0,0 +1,61 @@
+package com.tzld.ffmpeg.model.param;
+
+import com.alibaba.fastjson.JSON;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class VideoAddTailParam {
+    private String bizId;
+    private String originVideoUrl;
+    private String tailType;
+    private String tailVideoUrl;
+    private String tailAudioUrl;
+    private String assSubtitle;
+    private Integer srtMillisDuration;
+    // 原视频音量 1-100
+    private Integer originVideoVolume;
+    // 片尾音量 1-100
+    private Integer tailVolume;
+
+    public static void main(String[] args) {
+        VideoAddTailParam param = new VideoAddTailParam();
+        param.setOriginVideoUrl("http://testres.cybertogether.net/test/2.mp4");
+        param.setTailType("lastFrame");
+        param.setTailVideoUrl("http://testres.cybertogether.net/test/7.mp4");
+        param.setTailAudioUrl("http://testres.cybertogether.net/test/2.mp3");
+        param.setAssSubtitle("[Script Info]\n" +
+                "; Script generated by Aegisub 3.2.2\n" +
+                "; http://www.aegisub.org/\n" +
+                "Title: Default Aegisub file\n" +
+                "ScriptType: v4.00+\n" +
+                "WrapStyle: 0\n" +
+                "ScaledBorderAndShadow: yes\n" +
+                "YCbCr Matrix: None\n" +
+                "PlayResX: 100\n" +
+                "PlayResY: 100\n" +
+                "\n" +
+                "[Aegisub Project Garbage]\n" +
+                "Last Style Storage: Default\n" +
+                "Active Line: 1\n" +
+                "\n" +
+                "[V4+ Styles]\n" +
+                "Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, " +
+                "Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, " +
+                "Alignment, MarginL, MarginR, MarginV, Encoding\n" +
+                "Style: Default,PingFang SC,6,&H00000000,&H00000000,&H0000DEFF,&HFF00DEFF,-1,0,0,0,100,100,0,0,3,0.1," +
+                "2,2,10,10,10,134\n" +
+                "\n" +
+                "\n" +
+                "[Events]\n" +
+                "Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n" +
+                "Dialogue: 0,00:00:00.04,00:00:04.06,Default,,0,0,0,,叠个千纸鹤再系个红飘带\n" +
+                "Dialogue: 0,00:00:04.12,00:00:08.24,Default,,0,0,0,,愿善良的人们天天好运来\n" +
+                "Dialogue: 0,00:00:08.24,00:00:12.76,Default,,0,0,0,,你勤劳生活美你健康春常\\N在\n" +
+                "Dialogue: 0,00:00:12.76,00:00:17.26,Default,,0,0,0,,你一生的忙碌为了笑逐颜\\N开\n" +
+                "Dialogue: 0,00:00:18.12,00:00:22.44,Default,,0,0,0,,打个中国结请春风剪个彩\n");
+        param.setSrtMillisDuration(22044);
+        System.out.println(JSON.toJSONString(param));
+    }
+}

src/main/java/com/tzld/ffmpeg/model/param/VideoInfoParam.java

@@ -0,0 +1,10 @@
+package com.tzld.ffmpeg.model.param;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class VideoInfoParam {
+    private String videoUrl;
+}

src/main/java/com/tzld/ffmpeg/model/param/VideoTextureParam.java

@@ -0,0 +1,12 @@
+package com.tzld.ffmpeg.model.param;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class VideoTextureParam {
+    private String videoUrl;
+    private String imageUrl;
+    private Integer border;
+}

src/main/java/com/tzld/ffmpeg/model/param/VideoTimeCutParam.java

@@ -0,0 +1,12 @@
+package com.tzld.ffmpeg.model.param;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class VideoTimeCutParam {
+    private String videoUrl;
+    private String startTime;
+    private String endTime;
+}

src/main/java/com/tzld/ffmpeg/model/param/VideoTimeExtraFrameParam.java

@@ -0,0 +1,12 @@
+package com.tzld.ffmpeg.model.param;
+
+import lombok.Getter;
+import lombok.Setter;
+
+
+@Getter
+@Setter
+public class VideoTimeExtraFrameParam {
+    private String videoUrl;
+    private String time;
+}

src/main/java/com/tzld/ffmpeg/model/param/VideoTranscodingParam.java

@@ -0,0 +1,12 @@
+package com.tzld.ffmpeg.model.param;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class VideoTranscodingParam {
+    private String videoUrl;
+    private String coding;
+    private String bitrate;
+}

src/main/java/com/tzld/ffmpeg/model/param/VideoUrlsParam.java

@@ -0,0 +1,16 @@
+package com.tzld.ffmpeg.model.param;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+import java.util.List;
+
+@Getter
+@Setter
+@Accessors(chain = true)
+public class VideoUrlsParam {
+    private List<String> videoUrls;
+
+    private Integer pretreatmentSwitch;
+}

src/main/java/com/tzld/ffmpeg/model/vo/FileInfo.java

@@ -0,0 +1,25 @@
+package com.tzld.ffmpeg.model.vo;
+
+import lombok.Data;
+
+/**
+ * @author sunxy
+ */
+@Data
+public class FileInfo {
+
+    /**
+     * 文件名
+     */
+    private String fileName;
+
+    /**
+     * 文件URL
+     */
+    private String fileUrl;
+
+    /**
+     * 文件Size，单位KB
+     */
+    private Double fileSize;
+}

src/main/java/com/tzld/ffmpeg/model/vo/PolicyDetailVO.java

@@ -0,0 +1,49 @@
+package com.tzld.ffmpeg.model.vo;
+
+import java.util.List;
+
+public class PolicyDetailVO {
+	public List<PolicyVO> Statement;
+	public String Version;
+
+	public List<PolicyVO> getStatement() {
+		return Statement;
+	}
+
+	public void setStatement(List<PolicyVO> statement) {
+		Statement = statement;
+	}
+
+	public String getVersion() {
+		return Version;
+	}
+
+	public void setVersion(String version) {
+		Version = version;
+	}
+
+	public static class PolicyVO {
+		public List<String> Action;
+		public String Effect;
+		public List<String> Resource;
+		public List<String> getAction() {
+			return Action;
+		}
+		public void setAction(List<String> action) {
+			Action = action;
+		}
+		public String getEffect() {
+			return Effect;
+		}
+		public void setEffect(String effect) {
+			Effect = effect;
+		}
+		public List<String> getResource() {
+			return Resource;
+		}
+		public void setResource(List<String> resource) {
+			Resource = resource;
+		}
+		
+	}
+}

src/main/java/com/tzld/ffmpeg/model/vo/SignatureVO.java

@@ -0,0 +1,13 @@
+package com.tzld.ffmpeg.model.vo;
+
+import lombok.Data;
+
+@Data
+public class SignatureVO {
+    private String accessId;
+    private String policy;
+    private String signature;
+    private String fileName;
+    private String host;
+    private String expire;
+}

src/main/java/com/tzld/ffmpeg/model/vo/StsTokenVO.java

@@ -0,0 +1,20 @@
+package com.tzld.ffmpeg.model.vo;
+
+import lombok.Data;
+
+@Data
+public class StsTokenVO {
+    private String Expiration;
+    private String AccessKeyId;
+    private String AccessKeySecret;
+    private String SecurityToken;
+    private String RequestId;
+    private String FileName;
+    private String Host;
+    private String[] Hosts;
+    private String Bucket;
+    private String Region;
+    private Boolean Cname;
+    private Long serverTimestamp;
+
+}

src/main/java/com/tzld/ffmpeg/service/FFmpegService.java

@@ -0,0 +1,43 @@
+package com.tzld.ffmpeg.service;
+
+
+import com.tzld.ffmpeg.model.param.*;
+
+import java.util.List;
+
+public interface FFmpegService {
+
+    String mergeBgVideo(MergeBgVideoParam param);
+
+    String removeBg(RemoveBgParam param);
+
+    String videoAddAssSubtitle(VideoAddAssSubtitleParam param);
+
+    List<String> videoExtraAudio(VideoUrlsParam param);
+
+    String mediaSimpleMerge(MediaSimpleMergeParam param);
+
+    String videoTexture(VideoTextureParam param);
+
+    String videoInfo(String videoUrl);
+
+    String videoConcat(VideoUrlsParam param);
+
+    String videoAddTail(VideoAddTailParam param);
+
+    String videoTranscoding(VideoTranscodingParam param);
+
+    String videoAddAudio(VideoAddAudioParam param);
+
+    String videoTimeExtraFrame(VideoTimeExtraFrameParam param);
+
+    String timeCutVideo(VideoTimeCutParam param);
+
+    String timeExtraAudio(VideoTimeCutParam param);
+
+    String command(CommandParam param);
+
+    String audioVolume(AudioVolumeParam param);
+
+    String audioSplit(AudioSplitParam param);
+}

src/main/java/com/tzld/ffmpeg/service/ImageService.java

@@ -0,0 +1,62 @@
+package com.tzld.ffmpeg.service;
+
+import com.tzld.ffmpeg.exception.DownloadImageError;
+import com.tzld.ffmpeg.exception.SplicingImageError;
+import com.tzld.ffmpeg.model.param.DiverseSplicingImageParam;
+import com.tzld.ffmpeg.model.param.SimpleSplicingImageParam;
+import org.springframework.data.util.Pair;
+import org.springframework.lang.Nullable;
+
+import java.io.IOException;
+import java.util.List;
+
+public interface ImageService {
+    /**
+     * 为图片加蒙层
+     * @param imageUrl 图片链接
+     * @param alpha 蒙层透明度，例如0.01，越大越不透明
+     */
+    String imageLayer(String imageUrl, @Nullable Float alpha);
+    /**
+     * 为图片加蒙层
+     * @param imageUrl 图片链接
+     * @param alpha 蒙层透明度，例如0.01，越大越不透明
+     */
+    String imageLayer(String imageUrl, @Nullable String imageType, @Nullable Float alpha);
+
+    /**
+     * 下载图片
+     */
+    byte[] imageDownload(String imageUrl) throws DownloadImageError;
+
+    /**
+     *  下载图片
+     *
+     * @param imageUrl
+     * @return
+     * @throws DownloadImageError
+     */
+    byte[] imageDownloadV2(String imageUrl) throws DownloadImageError;
+
+    /**
+     * 多图片拼接
+     * 多少行、多少列
+     * 外层List定义行数，内层List定义每一行的列数
+     */
+    String imageSplicing(List<List<SimpleSplicingImageParam>> inputs) throws SplicingImageError;
+    /**
+     * 递归拼接图片
+     */
+    String imageSplicing(DiverseSplicingImageParam input) throws SplicingImageError;
+
+    /**
+     * 压缩图片
+     */
+    byte[] compress(String imageUrl, Integer targetHeight) throws DownloadImageError, IOException;
+
+    Pair<Integer, Integer> imageSize(String image) throws DownloadImageError, IOException;
+
+    boolean resourceIsAccessible(String url);
+
+    String transferAndStore(String imageUrl) throws DownloadImageError;;
+}

src/main/java/com/tzld/ffmpeg/service/impl/FFmpegServiceImpl.java

@@ -0,0 +1,1467 @@
+package com.tzld.ffmpeg.service.impl;
+
+import cn.hutool.core.collection.CollectionUtil;
+import com.alibaba.fastjson.JSON;
+import com.stuuudy.commons.external.filestorage.enums.EnumPublicBuckets;
+import com.tzld.ffmpeg.common.Constant;
+import com.tzld.ffmpeg.common.enums.ExceptionEnum;
+import com.tzld.ffmpeg.exception.CommonException;
+import com.tzld.ffmpeg.exception.DownloadImageError;
+import com.tzld.ffmpeg.model.dto.ali.AliVoiceResultSentenceData;
+import com.tzld.ffmpeg.model.param.*;
+import com.tzld.ffmpeg.service.FFmpegService;
+import com.tzld.ffmpeg.service.ImageService;
+import com.tzld.ffmpeg.util.*;
+import com.tzld.ffmpeg.util.http.HttpClientUtils;
+import com.tzld.ffmpeg.util.http.HttpResponseContent;
+import lombok.extern.slf4j.Slf4j;
+import okhttp3.Call;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+import org.apache.http.Header;
+import org.apache.http.util.TextUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+import javax.imageio.ImageIO;
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.io.*;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Service
+public class FFmpegServiceImpl implements FFmpegService {
+
+    @Autowired
+    ImageService imageService;
+
+    public static OkHttpClient client = new OkHttpClient().newBuilder()
+            .connectTimeout(15, TimeUnit.SECONDS)
+            .readTimeout(5, TimeUnit.MINUTES)
+            .writeTimeout(5, TimeUnit.MINUTES)
+            .retryOnConnectionFailure(true)
+            .build();
+
+    private void downloadFile(String url, String filePath) throws Exception {
+        for (int i = 0; i < 3; i++) {
+            try {
+                Request request = new Request.Builder()
+                        .url(url)
+                        .build();
+
+                Call call = client.newCall(request);
+                Response response = call.execute();
+                InputStream is = response.body().byteStream();
+
+                Path path = Paths.get(filePath);
+                Path parentDir = path.getParent();
+                if (!Files.exists(parentDir)) {
+                    Files.createDirectories(parentDir);
+                }
+                File file = new File(filePath);
+                FileOutputStream outputStream = new FileOutputStream(file);
+                byte[] buffer = new byte[4096];
+                int bytesRead;
+                while ((bytesRead = is.read(buffer)) != -1) {
+                    outputStream.write(buffer, 0, bytesRead);
+                }
+                is.close();
+                break;
+            } catch (Exception e) {
+                if (i == 2) {
+                    throw e;
+                } else {
+                    log.error("downloadFile error,{}", url, e);
+                }
+            }
+        }
+    }
+
+    @Override
+    public String mergeBgVideo(MergeBgVideoParam param) {
+        Set<String> allLocalFilePathList = new HashSet<>();
+        String mainVideoSuffix = ".mp4";
+        if (param.getMainVideo().contains(".mov")) {
+            mainVideoSuffix = ".mov";
+        }
+        String mainVideoFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + mainVideoSuffix;
+        String bgMediaFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4";
+        if ("image".equals(param.getType())) {
+            bgMediaFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".png";
+        }
+        String adjustBgMediaFilePath = bgMediaFilePath;
+        String outputFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4";
+        String ossKey = "ffmpeg/mergeBgVideo/" + BaseUtils.getUUIDStr() + ".mp4";
+
+        allLocalFilePathList.add(mainVideoFilePath);
+        allLocalFilePathList.add(bgMediaFilePath);
+        allLocalFilePathList.add(adjustBgMediaFilePath);
+        allLocalFilePathList.add(outputFilePath);
+        try {
+            downloadFile(CdnUtil.getOssHttpUrl(param.getMainVideo()), mainVideoFilePath);
+            downloadFile(CdnUtil.getOssHttpUrl(param.getBgMedia()), bgMediaFilePath);
+            // 调整背景视频/图片的尺寸、时长
+            adjustBgMediaFilePath = adjustBgMediaSizeAndDuration(mainVideoFilePath, bgMediaFilePath, param.getType(), allLocalFilePathList);
+            FFmpegUtil.mergeBgVideo(mainVideoFilePath, adjustBgMediaFilePath, outputFilePath);
+            // 上传到OSS
+            InputStream inputStream = new FileInputStream(outputFilePath);
+            AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, inputStream, "video/mp4");
+        } catch (Exception e) {
+            ossKey = null;
+            log.error("putObject error,{}", outputFilePath, e);
+        } finally {
+            if (CollectionUtil.isNotEmpty(allLocalFilePathList)) {
+                for (String filePath : allLocalFilePathList) {
+                    try {
+                        File file = new File(filePath);
+                        file.delete();
+                    } catch (Exception e) {
+                        log.error("delete file error,", filePath);
+                    }
+                }
+            }
+        }
+        return CdnUtil.getOssHttpUrl(ossKey);
+    }
+
+    private String adjustBgMediaSizeAndDuration(String mainVideoFilePath, String bgMediaFilePath, String type,
+                                                Set<String> allLocalFilePathList) throws IOException {
+        // 背景视频/图片 按短边缩放再居中裁剪
+        FFmpegUtil.MediaInfo mainVideoMediaInfo = FFmpegUtil.getMediaInfo(mainVideoFilePath);
+        int width = mainVideoMediaInfo.getWidth();
+        int height = mainVideoMediaInfo.getHeight();
+        int duration = mainVideoMediaInfo.getDuration();
+        if ("image".equals(type)) {
+            BufferedImage bgImage = ImageIO.read(new File(bgMediaFilePath));
+            if (bgImage.getWidth() == width && bgImage.getHeight() == height) {
+                return bgMediaFilePath;
+            }
+            String resizeImageFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".png";
+            allLocalFilePathList.add(resizeImageFilePath);
+            BigDecimal widthRate = new BigDecimal(width).divide(new BigDecimal(bgImage.getWidth()), 2,
+                    RoundingMode.UP);
+            BigDecimal heightRate = new BigDecimal(height).divide(new BigDecimal(bgImage.getHeight()), 2,
+                    RoundingMode.UP);
+            if (widthRate.compareTo(heightRate) > 0) {
+                int resizeHeight = widthRate.multiply(new BigDecimal(bgImage.getHeight())).intValue();
+                BufferedImage resizeImage = resizeImage(bgImage, width, resizeHeight);
+                if (resizeHeight > height) {
+                    resizeImage = resizeImage.getSubimage(0, (resizeHeight - height) / 2, width, height);
+                }
+                ImageIO.write(resizeImage, "png", new File(resizeImageFilePath));
+            } else {
+                int resizeWidth = heightRate.multiply(new BigDecimal(bgImage.getWidth())).intValue();
+                BufferedImage resizeImage = resizeImage(bgImage, resizeWidth, height);
+                if (resizeWidth > width) {
+                    resizeImage = resizeImage.getSubimage((resizeWidth - width) / 2, 0, width, height);
+                }
+                ImageIO.write(resizeImage, "png", new File(resizeImageFilePath));
+            }
+            return resizeImageFilePath;
+        } else {
+            FFmpegUtil.MediaInfo bgVideoMediaInfo = FFmpegUtil.getMediaInfo(bgMediaFilePath);
+            String resizeBgVideoFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4";
+            allLocalFilePathList.add(resizeBgVideoFilePath);
+            if (bgVideoMediaInfo.getWidth() == width && bgVideoMediaInfo.getHeight() == height) {
+                resizeBgVideoFilePath = bgMediaFilePath;
+            } else {
+                BigDecimal widthRate = new BigDecimal(width).divide(new BigDecimal(bgVideoMediaInfo.getWidth()), 2,
+                        RoundingMode.UP);
+                BigDecimal heightRate = new BigDecimal(height).divide(new BigDecimal(bgVideoMediaInfo.getHeight()), 2,
+                        RoundingMode.UP);
+                String clipParams;
+                if (widthRate.compareTo(heightRate) > 0) {
+                    int cropX = 0;
+                    int resizeHeight = widthRate.multiply(new BigDecimal(bgVideoMediaInfo.getHeight())).intValue();
+                    int cropY = (resizeHeight - height) / 2;
+                    clipParams = "scale=" + width + ":-1,crop=" + width + ":" + height + ":" + cropX + ":" + cropY;
+                } else {
+                    int resizeWidth = heightRate.multiply(new BigDecimal(bgVideoMediaInfo.getWidth())).intValue();
+                    int cropX = (resizeWidth - width) / 2;
+                    int cropY = 0;
+                    clipParams = "scale=-1:" + height + ",crop=" + width + ":" + height + ":" + cropX + ":" + cropY;
+                }
+                FFmpegUtil.clipVideo(bgMediaFilePath, clipParams, resizeBgVideoFilePath);
+            }
+            if (bgVideoMediaInfo.getDuration() < duration) {
+                // 循环播放
+                int count = duration / bgVideoMediaInfo.getDuration();
+                int mod = duration % bgVideoMediaInfo.getDuration();
+                int loop = count - 1;
+                if (mod > 0) {
+                    loop = loop + 1;
+                }
+                String loopBgVideoFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4";
+                allLocalFilePathList.add(loopBgVideoFilePath);
+                FFmpegUtil.loopVideo(resizeBgVideoFilePath, loop, loopBgVideoFilePath);
+                FFmpegUtil.MediaInfo loopMediaInfo = FFmpegUtil.getMediaInfo(loopBgVideoFilePath);
+                if (loopMediaInfo.getDuration() > duration) {
+                    // 截断
+                    String cutBgVideoFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4";
+                    allLocalFilePathList.add(cutBgVideoFilePath);
+                    String startTime = "00:00:00.000";
+                    String cutTime = covertFFmpegCutTime(duration);
+                    FFmpegUtil.cutVideo(loopBgVideoFilePath, startTime, cutTime, cutBgVideoFilePath);
+                    return cutBgVideoFilePath;
+                } else {
+                    return loopBgVideoFilePath;
+                }
+            } else if (bgVideoMediaInfo.getDuration() > duration) {
+                // 截断
+                String cutBgVideoFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4";
+                allLocalFilePathList.add(cutBgVideoFilePath);
+                String startTime = "00:00:00.000";
+                String cutTime = covertFFmpegCutTime(duration);
+                FFmpegUtil.cutVideo(resizeBgVideoFilePath, startTime, cutTime, cutBgVideoFilePath);
+                return cutBgVideoFilePath;
+            } else {
+                return resizeBgVideoFilePath;
+            }
+        }
+    }
+
+    private String covertFFmpegCutTime(int millis) {
+        int second = millis / 1000;
+        String mod = millis % 1000 + "";
+        // 补0
+        if (mod.length() == 0) {
+            mod = "000";
+        } else if (mod.length() == 1) {
+            mod = "00" + mod;
+        } else if (mod.length() == 2) {
+            mod = "0" + mod;
+        }
+        return second + "." + mod;
+    }
+
+    private static BufferedImage resizeImage(BufferedImage originalImage, int width, int height) {
+        Image scaledImage = originalImage.getScaledInstance(width, height, Image.SCALE_SMOOTH);
+        BufferedImage resizedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
+
+        Graphics2D g2d = resizedImage.createGraphics();
+        g2d.drawImage(scaledImage, 0, 0, null);
+        g2d.dispose();
+
+        return resizedImage;
+    }
+
+    @Override
+    public String removeBg(RemoveBgParam param) {
+        String inputFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4";
+        String outputFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mov";
+        String ossKey = "ffmpeg/removeBg/" + BaseUtils.getUUIDStr() + ".mov";
+        String contentType = "video/mov";
+        if ("image".endsWith(param.getMediaType())) {
+            inputFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".png";
+            outputFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".png";
+            ossKey = "ffmpeg/removeBg/" + BaseUtils.getUUIDStr() + ".png";
+            contentType = "image/png";
+        }
+
+        String webmOutputFilePath = "";
+
+        try {
+            downloadFile(CdnUtil.getOssHttpUrl(param.getMediaUrl()), inputFilePath);
+            String colorAndSF = param.getColor();
+            if ("0xFFFFFF".equals(colorAndSF)) {
+                // 去除白幕，相似度和混合度需要特殊设置
+                colorAndSF = colorAndSF + ":0.01:0.01";
+            } else if ("0x00FF00".equals(colorAndSF)) {
+                colorAndSF = colorAndSF + ":0.2:0.1";
+            }
+            FFmpegUtil.removeBg(inputFilePath, colorAndSF, outputFilePath);
+            // 上传到OSS
+            InputStream inputStream = new FileInputStream(outputFilePath);
+            AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, inputStream, contentType);
+
+            // 如果是mov视频，还需要多转一份webm格式的视频，才能在浏览器中显示
+            if (outputFilePath.contains(".mov")) {
+                webmOutputFilePath = outputFilePath.replace(".mov", ".webm");
+                FFmpegUtil.movToWebm(outputFilePath, webmOutputFilePath);
+                String webmOssKey = ossKey.replace(".mov", ".webm");
+                InputStream inputStreamWebm = new FileInputStream(webmOutputFilePath);
+                AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), webmOssKey, inputStreamWebm, "video/webm");
+            }
+        } catch (Exception e) {
+            ossKey = null;
+            log.error("putObject error,{}", outputFilePath, e);
+        } finally {
+            try {
+                File fileMain = new File(inputFilePath);
+                fileMain.delete();
+
+                File fileOut = new File(outputFilePath);
+                fileOut.delete();
+
+                if (StringUtils.hasText(webmOutputFilePath)) {
+                    File fileWebmOut = new File(webmOutputFilePath);
+                    fileWebmOut.delete();
+                }
+            } catch (Exception e) {
+                log.error("delete file error {}", outputFilePath);
+            }
+        }
+        return CdnUtil.getOssHttpUrl(ossKey);
+    }
+
+    @Override
+    public String videoAddAssSubtitle(VideoAddAssSubtitleParam param) {
+        String inputFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4";
+        String outputFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4";
+        String assSubtitleFilePath = "./datalog/videoComposite/subtitle/" + BaseUtils.getUUIDStr() + ".ass";
+        String ossKey = "ffmpeg/videoAddAssSubtitle/" + BaseUtils.getUUIDStr() + ".mp4";
+        try {
+            downloadFile(CdnUtil.getOssHttpUrl(param.getVideoUrl()), inputFilePath);
+            FileUtils.saveFileContent(assSubtitleFilePath, param.getAssSubtitle().getBytes());
+            String inputSubtitleAndStyle = "subtitles=" + assSubtitleFilePath;
+            FFmpegUtil.addSubtitle(inputFilePath, inputSubtitleAndStyle, outputFilePath);
+            // 上传到OSS
+            InputStream inputStream = new FileInputStream(outputFilePath);
+            AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, inputStream, "video/mp4");
+        } catch (Exception e) {
+            ossKey = null;
+            log.error("videoAddAssSubtitle error,{}", outputFilePath, e);
+        } finally {
+            try {
+                File fileIn = new File(inputFilePath);
+                fileIn.delete();
+
+                File fileOut = new File(outputFilePath);
+                fileOut.delete();
+
+                File fileAss = new File(assSubtitleFilePath);
+                fileAss.delete();
+            } catch (Exception e) {
+                log.error("delete file error {}", outputFilePath);
+            }
+        }
+        return CdnUtil.getOssHttpUrl(ossKey);
+    }
+
+    @Override
+    public List<String> videoExtraAudio(VideoUrlsParam param) {
+        if (CollectionUtil.isEmpty(param.getVideoUrls())) {
+            return new ArrayList<>();
+        }
+
+        List<String> result = new ArrayList<>();
+        for (String videoUrl : param.getVideoUrls()) {
+            String outputPath = null;
+            try {
+                outputPath = FFmpegUtil.getVideoVoice(videoUrl,
+                        FFmpegUtil.pathCreate("./datalog/videoExtractAudio/voice/" + BaseUtils.getUUIDStr() + ".mp3"));
+
+                if (StringUtils.hasText(outputPath)) {
+                    String ossKey = "video/voice/" + BaseUtils.getUUIDStr() + ".mp3";
+                    AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, Files.newInputStream(Paths.get(outputPath)), "audio/mp3");
+                    result.add(CdnUtil.getOssHttpUrl(ossKey));
+                }
+            } catch (Exception e) {
+                log.error("ffmpeg videoExtraAudio error, videoUrl = {}", videoUrl, e);
+            } finally {
+                try {
+                    if (StringUtils.hasText(outputPath)) {
+                        File file = new File(outputPath);
+                        boolean delete = file.delete();
+                    }
+                } catch (Exception e) {
+                    log.error("delete file error {}", outputPath);
+                }
+            }
+        }
+
+        return result;
+    }
+
+    @Override
+    public String audioVolume(AudioVolumeParam param) {
+        if (!StringUtils.hasText(param.getAudioUrl())) {
+            return "";
+        }
+
+        double volume = Optional.ofNullable(param.getVolume()).orElse(1d);
+
+        String url = param.getAudioUrl();
+        List<String> allLocalFilePathList = new ArrayList<>();
+        try {
+            String inputFilePath = FFmpegUtil.pathCreate("./datalog/audioVolume/audio/" + BaseUtils.getUUIDStr() + ".mp3");
+            downloadFile(url, inputFilePath);
+            allLocalFilePathList.add(inputFilePath);
+
+            // 音频降噪
+            String outputFilePath = FFmpegUtil.pathCreate("./datalog/audioVolume/audio/" + BaseUtils.getUUIDStr() + ".mp3");
+            allLocalFilePathList.add(outputFilePath);
+
+            String afParam = String.format("afftdn=nf=-20,volume=%s", volume);
+            FFmpegUtil.audioVolume(inputFilePath, outputFilePath, afParam);
+
+            String ossKey = String.format("audioVolume/%s.mp3", BaseUtils.getUUIDStr());
+            AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, Files.newInputStream(Paths.get(outputFilePath)));
+            return CdnUtil.getOssHttpUrl(ossKey);
+        } catch (Exception e) {
+            log.error("ffmpeg audioVolume error, url = {}", url, e);
+        } finally {
+            for (String localFilePath : allLocalFilePathList) {
+                try {
+                    new File(localFilePath).delete();
+                } catch (Exception e) {
+                    log.error("delete file error, localFilePath = {}", localFilePath, e);
+                }
+            }
+        }
+        return "";
+    }
+
+    @Override
+    public String audioSplit(AudioSplitParam param) {
+        log.info("audioSplit param = {}", param);
+        if (!StringUtils.hasText(param.getAudioUrl()) || Objects.isNull(param.getSegmentTime()) || param.getSegmentTime() <= 0) {
+            return "";
+        }
+
+        List<String> allLocalFilePathList = new ArrayList<>();
+
+        try {
+            String inputFile = FFmpegUtil.pathCreate("./datalog/audioSplit/audio/" + BaseUtils.getUUIDStr() + ".mp3");
+            downloadFile(param.getAudioUrl(), inputFile);
+            allLocalFilePathList.add(inputFile);
+
+            String outputPath = "./datalog/audioSplit/split/" + BaseUtils.getUUIDStr();
+            String outputFilePath = FFmpegUtil.pathCreate(outputPath + "/" + BaseUtils.getUUIDStr() + "_%03d.mp3");
+            FFmpegUtil.audioSplit(inputFile, param.getSegmentTime(), outputFilePath);
+
+            List<String> files = FFmpegUtil.ls(outputPath);
+            if (CollectionUtil.isEmpty(files)) {
+                return "";
+            }
+            allLocalFilePathList.addAll(files);
+
+            // 按照文件名的后几位数字排序
+            files = files.stream().sorted((f1, f2) -> {
+                String filename1 = Paths.get(f1).getFileName().toString();
+                String filename2 = Paths.get(f2).getFileName().toString();
+
+                // 提取数字部分
+                int num1 = extractNumber(filename1);
+                int num2 = extractNumber(filename2);
+
+                // 如果都能提取到数字，按数字排序
+                if (num1 != Integer.MAX_VALUE && num2 != Integer.MAX_VALUE) {
+                    return Integer.compare(num1, num2);
+                }
+
+                // 否则按文件名自然排序
+                return filename1.compareTo(filename2);
+            }).collect(Collectors.toList());
+
+            List<String> ossUrls = new ArrayList<>(files.size());
+            for (String file : files) {
+                Path path = Paths.get(file);
+                String ossKey = "audio/split/" + path.getFileName().toString();
+                AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, Files.newInputStream(path));
+                ossUrls.add(CdnUtil.getOssHttpUrl(ossKey));
+            }
+            if (ossUrls.size() != files.size()) {
+                return "";
+            }
+            return String.join(",", ossUrls);
+        } catch (Exception e) {
+            log.error("ffmpeg audioSplit error, url = {}", param.getAudioUrl(), e);
+        } finally {
+            for (String localFilePath : allLocalFilePathList) {
+                try {
+                    new File(localFilePath).delete();
+                } catch (Exception e) {
+                    log.error("delete file error, localFilePath = {}", localFilePath, e);
+                }
+            }
+        }
+
+        return "";
+    }
+
+    @Override
+    public String videoTimeExtraFrame(VideoTimeExtraFrameParam param) {
+        if (!StringUtils.hasText(param.getVideoUrl())
+                || !StringUtils.hasText(param.getTime())) {
+            return "";
+        }
+
+        String imageLocalPath = null;
+        try {
+            imageLocalPath = FFmpegUtil.getTimeImage(param.getVideoUrl(), param.getTime(),
+                    FFmpegUtil.pathCreate("./datalog/videoExtractKeyframe/image/" + BaseUtils.getUUIDStr() + ".jpg"), 0);
+            if (StringUtils.hasText(imageLocalPath)) {
+                String ossKey = "video/timeFrame/" + BaseUtils.getUUIDStr() + ".jpg";
+                AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey,
+                        Files.newInputStream(Paths.get(imageLocalPath)), "image/jpeg");
+                return CdnUtil.getOssHttpUrl(ossKey);
+            }
+        } catch (Exception e) {
+            log.error("ffmpeg videoTimeExtraFrame error, params = {}, ", JSON.toJSONString(param), e);
+        } finally {
+            if (StringUtils.hasText(imageLocalPath)) {
+                File file = new File(imageLocalPath);
+                file.delete();
+            }
+        }
+
+        return null;
+    }
+
+    @Override
+    public String timeCutVideo(VideoTimeCutParam param) {
+        if (!StringUtils.hasText(param.getVideoUrl())
+                || !StringUtils.hasText(param.getStartTime())
+                || !StringUtils.hasText(param.getEndTime())) {
+            return "";
+        }
+
+        String outputPath = "";
+        try {
+            outputPath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+            FFmpegUtil.cutVideoTime(param.getVideoUrl(), param.getStartTime(), param.getEndTime(), outputPath);
+            String ossKey = "video/video/" + BaseUtils.getUUIDStr() + ".mp4";
+            AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey,
+                    Files.newInputStream(Paths.get(outputPath)), "video/mp4");
+            return CdnUtil.getOssHttpUrl(ossKey);
+        } catch (Exception e) {
+            log.error("ffmpeg timeCutVideo error, params = {}, ", JSON.toJSONString(param), e);
+        } finally {
+            if (StringUtils.hasText(outputPath)) {
+                File file = new File(outputPath);
+                file.delete();
+            }
+        }
+
+        return null;
+    }
+
+    @Override
+    public String timeExtraAudio(VideoTimeCutParam param) {
+        if (!StringUtils.hasText(param.getVideoUrl())
+                || !StringUtils.hasText(param.getStartTime())
+                || !StringUtils.hasText(param.getEndTime())) {
+            return "";
+        }
+
+        String outputPath = null;
+        String inputVideoPath = null;
+        try {
+            inputVideoPath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+            FileUtils.saveFileContent(inputVideoPath, imageService.imageDownloadV2(param.getVideoUrl()));
+            outputPath = FFmpegUtil.getVideoVoice(inputVideoPath, param.getStartTime(), param.getEndTime(),
+                    FFmpegUtil.pathCreate("./datalog/videoExtractAudio/voice/" + BaseUtils.getUUIDStr() + ".mp3"));
+            if (StringUtils.hasText(outputPath)) {
+                String ossKey = "video/voice/" + BaseUtils.getUUIDStr() + ".mp3";
+                AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, Files.newInputStream(Paths.get(outputPath)), "audio/mp3");
+                return CdnUtil.getOssHttpUrl(ossKey);
+            }
+        } catch (Exception e) {
+            log.error("ffmpeg timeExtraAudio error, params = {}", JSON.toJSONString(param), e);
+        } finally {
+            try {
+                if (StringUtils.hasText(outputPath)) {
+                    File file = new File(outputPath);
+                    boolean delete = file.delete();
+                }
+                if (StringUtils.hasText(inputVideoPath)) {
+                    File file = new File(inputVideoPath);
+                    boolean delete = file.delete();
+                }
+            } catch (Exception e) {
+                log.error("delete file error {}, {}", outputPath, inputVideoPath);
+            }
+        }
+
+        return "";
+    }
+
+    @Override
+    public String command(CommandParam param) {
+        String ffmpegCommand = param.getFfmpegCommand();
+        List<String> allLocalFilePathList = new ArrayList<>();
+
+        try {
+            String outputFile = FFmpegUtil.pathCreate("./datalog/ffmpeg/command/result/" + param.getOutputFile());
+            allLocalFilePathList.add(outputFile);
+            ffmpegCommand = ffmpegCommand.replace(param.getOutputFile(), outputFile);
+            ffmpegCommand = ffmpegCommand.replace("\n", " ").replace("\\", "").trim();
+            List<String> commands = splitCommands(ffmpegCommand);
+            FFmpegUtil.FFmpegCommandResult fFmpegCommandResult = FFmpegUtil.executeFFmpegCommand(commands);
+            if (!fFmpegCommandResult.isSuccessful()) {
+                throw new CommonException(ExceptionEnum.SYSTEM_ERROR.getCode(),
+                        "执行出错，" + JSON.toJSONString(fFmpegCommandResult)
+                );
+            }
+
+            if ("video".equals(param.getOutputType())) {
+                String ossKey = "videoComposite/" + BaseUtils.getUUIDStr() + ".mp4";
+                AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, Files.newInputStream(Paths.get(outputFile)), "video/mp4");
+                return CdnUtil.getOssHttpUrl(ossKey);
+            } else if ("audio".equals(param.getOutputType())) {
+                String ossKey = "videoComposite/" + BaseUtils.getUUIDStr() + ".mp3";
+                AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, Files.newInputStream(Paths.get(outputFile)), "audio/mpeg");
+                return CdnUtil.getOssHttpUrl(ossKey);
+            } else if ("image".equals(param.getOutputType())) {
+                String ossKey = "videoComposite/" + BaseUtils.getUUIDStr() + ".jpg";
+                AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, Files.newInputStream(Paths.get(outputFile)), "image/jpeg");
+                return CdnUtil.getOssHttpUrl(ossKey);
+            } else {
+                String ossKey = "videoComposite/" + BaseUtils.getUUIDStr() + ".txt";
+                AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, Files.newInputStream(Paths.get(outputFile)), "text/plain");
+                return CdnUtil.getOssHttpUrl(ossKey);
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        } finally {
+            for (String s : allLocalFilePathList) {
+                File file = new File(s);
+                boolean delete = file.delete();
+            }
+        }
+
+
+    }
+
+    private List<String> splitCommands(String ffmpegCommand) {
+        List<String> parts = new ArrayList<>();
+        boolean inQuotes = false;
+        StringBuilder current = new StringBuilder();
+
+        for (char c : ffmpegCommand.toCharArray()) {
+            if (c == '"') {
+                inQuotes = !inQuotes;
+            } else if (c == ' ' && !inQuotes) {
+                if (current.length() > 0) {
+                    parts.add(current.toString());
+                    current.setLength(0);
+                }
+            } else {
+                current.append(c);
+            }
+        }
+
+        if (current.length() > 0) {
+            parts.add(current.toString());
+        }
+        return parts.stream().filter(StringUtils::hasText).collect(Collectors.toList());
+    }
+
+    @Override
+    public String mediaSimpleMerge(MediaSimpleMergeParam param) {
+        if (CollectionUtil.isEmpty(param.getVideoUrls())) {
+            return null;
+        }
+
+        try {
+            // 视频拼接
+            String videoUrl = videoTogether(param.getVideoUrls());
+
+            // 音频拼接
+            if (CollectionUtil.isEmpty(param.getAudioUrls())) {
+                return videoUrl;
+            }
+            String audioUrl = audioTogether(param.getAudioUrls());
+
+            // 音视频合并
+            if (TextUtils.isBlank(audioUrl)) {
+                return videoUrl;
+            }
+            String result = mediaMerge(videoUrl, audioUrl);
+
+            return result;
+        } catch (Exception e) {
+            log.error("ffmpeg mediaSimpleMerge error", e);
+            return null;
+        }
+    }
+
+    @Override
+    public String videoTexture(VideoTextureParam param) {
+        if (TextUtils.isBlank(param.getImageUrl()) || TextUtils.isBlank(param.getVideoUrl())) {
+            log.error("videoTexture missing necessary parameters, param = {}", JSON.toJSONString(param));
+            throw new CommonException(ExceptionEnum.PARAM_ERROR.getCode(), "videoTexture missing necessary " +
+                    "parameters, param:" + JSON.toJSONString(param));
+        }
+
+        List<String> allLocalFilePathList = new ArrayList<>();
+        long beginTime = System.currentTimeMillis();
+        try {
+            String videoPath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+            FileUtils.saveFileContent(videoPath, imageService.imageDownloadV2(param.getVideoUrl()));
+            allLocalFilePathList.add(videoPath);
+            long time1 = System.currentTimeMillis();
+            log.info("videoTexture,time1:{},{}", (time1 - beginTime), param.getVideoUrl());
+            // 获取视频宽高
+            FFmpegUtil.MediaInfo videoMediaInfo = FFmpegUtil.getMediaInfo(videoPath);
+            long time2 = System.currentTimeMillis();
+            log.info("videoTexture,time2:{},{}", (time2 - time1), param.getVideoUrl());
+
+            String imagePath = FFmpegUtil.pathCreate("./datalog/videoComposite/image/" + BaseUtils.getUUIDStr() + ".png");
+            FileUtils.saveFileContent(imagePath, imageService.imageDownloadV2(param.getImageUrl()));
+            allLocalFilePathList.add(imagePath);
+            long time3 = System.currentTimeMillis();
+            log.info("videoTexture,time3:{},{}", (time3 - time2), param.getVideoUrl());
+
+            BufferedImage originImage = ImageIO.read(new File(imagePath));
+            boolean needCrop = false;
+            // 图片尺寸过大，需要裁剪
+            if (originImage.getWidth() > videoMediaInfo.getWidth().intValue()
+                    || originImage.getHeight() > videoMediaInfo.getHeight().intValue()) {
+                needCrop = true;
+            } else {
+                BigDecimal widthMultiply =
+                        new BigDecimal(originImage.getWidth()).divide(new BigDecimal(videoMediaInfo.getWidth()), 2, RoundingMode.HALF_UP);
+                BigDecimal heightMultiply =
+                        new BigDecimal(originImage.getHeight()).divide(new BigDecimal(videoMediaInfo.getHeight()), 2, RoundingMode.HALF_UP);
+                if (widthMultiply.compareTo(new BigDecimal("0.4")) > 0 || heightMultiply.compareTo(new BigDecimal("0.4")) > 0) {
+                    needCrop = true;
+                }
+            }
+            // 图片尺寸过大，需要裁剪
+            if (needCrop) {
+                originImage = ImageUtils.cropTransparentImageByShort(originImage, videoMediaInfo.getWidth(), videoMediaInfo.getHeight());
+                ImageIO.write(originImage, "PNG", new File(imagePath));
+                long time4 = System.currentTimeMillis();
+                log.info("videoTexture,time4:{},{}", (time4 - time3), param.getVideoUrl());
+            }
+
+            String outputPath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+            allLocalFilePathList.add(outputPath);
+
+            // 贴图操作
+            FFmpegUtil.videoTexture(videoPath, imagePath,
+                    videoMediaInfo.getWidth() - (originImage.getWidth() + Optional.ofNullable(param.getBorder()).orElse(0)),
+                    videoMediaInfo.getHeight() - (originImage.getHeight() + Optional.ofNullable(param.getBorder()).orElse(0)),
+                    outputPath);
+            long time5 = System.currentTimeMillis();
+            log.info("videoTexture,time5:{},{}", (time5 - time3), param.getVideoUrl());
+            // 转存
+            String ossKey = "videoComposite/" + BaseUtils.getUUIDStr() + ".mp4";
+            AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, Files.newInputStream(Paths.get(outputPath)), "video/mp4");
+            long time6 = System.currentTimeMillis();
+            log.info("videoTexture,time6:{},{}", (time6 - time5), param.getVideoUrl());
+            return CdnUtil.getOssHttpUrl(ossKey);
+        } catch (Exception e) {
+            log.error("videoTexture error, request param = {}", JSON.toJSONString(param), e);
+            throw new CommonException(ExceptionEnum.SYSTEM_ERROR.getCode(), "videoTexture error," + e.getMessage());
+        } finally {
+            if (CollectionUtil.isNotEmpty(allLocalFilePathList)) {
+                for (String filePath : allLocalFilePathList) {
+                    try {
+                        File file = new File(filePath);
+                        file.delete();
+                    } catch (Exception e) {
+                        log.error("delete file error,", filePath);
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public String videoInfo(String videoUrl) {
+        FFmpegUtil.MediaInfo mediaInfo = FFmpegUtil.getMediaInfo(videoUrl);
+        return JSON.toJSONString(mediaInfo);
+    }
+
+    private String mediaMerge(String videoUrl, String audioUrl) throws IOException, DownloadImageError {
+        if (TextUtils.isBlank(videoUrl) || TextUtils.isBlank(audioUrl)) {
+            return null;
+        }
+        List<String> allLocalFilePathList = new ArrayList<>();
+
+        String videoPath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+        FileUtils.saveFileContent(videoPath, imageService.imageDownloadV2(videoUrl));
+        allLocalFilePathList.add(videoPath);
+        String audioPath = FFmpegUtil.pathCreate("./datalog/videoComposite/filelist/" + BaseUtils.getUUIDStr() + ".mp3");
+        FileUtils.saveFileContent(audioPath, imageService.imageDownloadV2(audioUrl));
+        allLocalFilePathList.add(audioPath);
+
+        String outputPath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+        allLocalFilePathList.add(outputPath);
+        FFmpegUtil.addAudioSelfAdaption(videoPath, audioPath, outputPath);
+        String ossKey = "videoComposite/" + BaseUtils.getUUIDStr() + ".mp4";
+        AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, Files.newInputStream(Paths.get(outputPath)), "video/mp4");
+        for (String s : allLocalFilePathList) {
+            File file = new File(s);
+            boolean delete = file.delete();
+        }
+
+        return CdnUtil.getOssHttpUrl(ossKey);
+    }
+
+    private String audioTogether(List<String> audioUrls) throws DownloadImageError, IOException {
+        List<String> allLocalFilePathList = new ArrayList<>();
+        StringBuilder concatContent = new StringBuilder();
+        for (String audioUrl : audioUrls) {
+            String audioPath = FFmpegUtil.pathCreate("./datalog/videoComposite/filelist/" + BaseUtils.getUUIDStr() + ".mp3");
+            FileUtils.saveFileContent(audioPath, imageService.imageDownloadV2(audioUrl));
+            allLocalFilePathList.add(audioPath);
+            concatContent.append("file '").append(audioPath).append("'").append("\n");
+        }
+        String concatFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/ace/" + BaseUtils.getUUIDStr() + ".txt");
+        FileUtils.saveFileContent(concatFilePath, concatContent.toString().trim().getBytes());
+        allLocalFilePathList.add(concatFilePath);
+        String concatOutputFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/ace/" + BaseUtils.getUUIDStr() + ".mp3");
+        FFmpegUtil.concatAudios(concatFilePath, concatOutputFilePath);
+        allLocalFilePathList.add(concatOutputFilePath);
+        String ossKey = "composeAceAudio/" + BaseUtils.getUUIDStr() + ".mp3";
+        AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, Files.newInputStream(Paths.get(concatOutputFilePath)), "audio/mp3");
+        for (String s : allLocalFilePathList) {
+            File file = new File(s);
+            boolean delete = file.delete();
+        }
+
+        return CdnUtil.getOssHttpUrl(ossKey);
+    }
+
+    private String videoTogether(List<String> videoUrls) throws DownloadImageError, IOException {
+        List<String> allLocalFilePathList = new ArrayList<>();
+        // 视频片段拼接
+        StringBuilder concatContent = new StringBuilder();
+        for (String videoUrl : videoUrls) {
+            String videoPath = FFmpegUtil.pathCreate("./datalog/videoComposite/filelist/" + BaseUtils.getUUIDStr() + ".mp4");
+            FileUtils.saveFileContent(videoPath, imageService.imageDownloadV2(videoUrl));
+            concatContent.append("file '").append(videoPath).append("'").append("\n");
+            allLocalFilePathList.add(videoPath);
+        }
+        String concatFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/filelist/" + BaseUtils.getUUIDStr() + ".txt");
+        FileUtils.saveFileContent(concatFilePath, concatContent.toString().trim().getBytes());
+        allLocalFilePathList.add(concatFilePath);
+        String concatVideoPath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+        FFmpegUtil.concatVideos(concatFilePath, concatVideoPath);
+        allLocalFilePathList.add(concatVideoPath);
+        String ossKey = "videoComposite/" + BaseUtils.getUUIDStr() + ".mp4";
+        AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, Files.newInputStream(Paths.get(concatVideoPath)), "video/mp4");
+        for (String s : allLocalFilePathList) {
+            File file = new File(s);
+            boolean delete = file.delete();
+        }
+
+        return CdnUtil.getOssHttpUrl(ossKey);
+    }
+
+    @Override
+    public String videoConcat(VideoUrlsParam param) {
+        List<String> allLocalFilePathList = new ArrayList<>();
+        try {
+            String concatFileContent = buildConcatFileContentV2(param.getVideoUrls(), allLocalFilePathList, param.getPretreatmentSwitch());
+            String concatFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/filelist/" + BaseUtils.getUUIDStr() + ".txt");
+            FileUtils.saveFileContent(concatFilePath, concatFileContent.getBytes());
+            allLocalFilePathList.add(concatFilePath);
+
+            String outputFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4";
+            allLocalFilePathList.add(outputFilePath);
+
+            FFmpegUtil.concatVideos(concatFilePath, outputFilePath);
+
+            // 上传到oss中
+            String ossKey = "videoComposite/" + BaseUtils.getUUIDStr() + ".mp4";
+            InputStream inputStream = new FileInputStream(outputFilePath);
+            AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, inputStream, "video/mp4");
+            return CdnUtil.getOssHttpUrl(ossKey);
+        } catch (Exception e) {
+            log.error("videoConcat error,param:{}", JSON.toJSONString(param), e);
+            throw new CommonException(ExceptionEnum.SYSTEM_ERROR.getCode(), e.getMessage());
+        } finally {
+            if (CollectionUtil.isNotEmpty(allLocalFilePathList)) {
+                for (String filePath : allLocalFilePathList) {
+                    try {
+                        File file = new File(filePath);
+                        file.delete();
+                    } catch (Exception e) {
+                        log.error("delete file error,", filePath);
+                    }
+                }
+            }
+        }
+    }
+
+    @Deprecated
+    private String buildConcatFileContent(List<String> clipVideoUrls, List<String> allLocalFilePathList) throws Exception {
+        List<String> scaleVideoFilePathList = new ArrayList<>();
+        // 以第一个视频的宽高为准，其他视频宽高不一致，缩放裁剪处理
+        int finalWidth = 720;
+        int finalHeight = 1280;
+        for (int i = 0; i < clipVideoUrls.size(); i++) {
+            String clipVideoUrl = clipVideoUrls.get(i);
+            String clipVideoFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+            downloadFile(clipVideoUrl, clipVideoFilePath);
+            allLocalFilePathList.add(clipVideoFilePath);
+            FFmpegUtil.MediaInfo mediaInfo = FFmpegUtil.getMediaInfo(clipVideoFilePath);
+            if (i == 0) {
+                finalWidth = mediaInfo.getWidth();
+                finalHeight = mediaInfo.getHeight();
+                // 确保宽高可以被2整除
+                if (finalWidth % 2 != 0) {
+                    finalWidth = finalWidth + 1;
+                }
+                if (finalHeight % 2 != 0) {
+                    finalHeight = finalHeight + 1;
+                }
+            }
+            if (mediaInfo.getWidth() == finalWidth && mediaInfo.getHeight() == finalHeight) {
+                scaleVideoFilePathList.add(clipVideoFilePath);
+            } else {
+                int width = mediaInfo.getWidth();
+                int height = mediaInfo.getHeight();
+                double wRate =
+                        new BigDecimal(finalWidth).divide(new BigDecimal(width), 4, RoundingMode.HALF_UP).doubleValue();
+                double hRate =
+                        new BigDecimal(finalHeight).divide(new BigDecimal(height), 4, RoundingMode.HALF_UP).doubleValue();
+                String clipParams;
+                if (wRate >= hRate) {
+                    int cropX = 0;
+                    int targetHeight = (finalWidth * height) / width;
+                    if (targetHeight % 2 != 0) {
+                        targetHeight = targetHeight + 1;
+                    }
+                    int cropY = (targetHeight - finalHeight) / 2;
+                    if (cropY < 0) {
+                        cropY = 0;
+                    }
+                    clipParams =
+                            "scale=" + finalWidth + ":" + targetHeight + ",crop=" + finalWidth + ":" + finalHeight + ":" + cropX +
+                                    ":" + cropY;
+                } else {
+                    int targetWidth = (finalHeight * width) / height;
+                    if (targetWidth % 2 != 0) {
+                        targetWidth = targetWidth + 1;
+                    }
+                    int cropX = (targetWidth - finalWidth) / 2;
+                    if (cropX < 0) {
+                        cropX = 0;
+                    }
+                    int cropY = 0;
+                    clipParams =
+                            "scale=" + targetWidth + ":" + finalHeight + ",crop=" + finalWidth + ":" + finalHeight + ":" + cropX +
+                                    ":" + cropY;
+                }
+                String scaleClipVideoPath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+//                System.out.println("clipVideoUrl:" + clipVideoUrl);
+                FFmpegUtil.clipVideo(clipVideoFilePath, clipParams, scaleClipVideoPath);
+                allLocalFilePathList.add(scaleClipVideoPath);
+
+                scaleVideoFilePathList.add(scaleClipVideoPath);
+            }
+        }
+        // 处理视频时间戳，避免拼接后时长不对问题
+        StringBuilder concatContent = new StringBuilder();
+        for (String scaleVideoFilePath : scaleVideoFilePathList) {
+            String timeScaleVideoPath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+            FFmpegUtil.fixVideoTime(scaleVideoFilePath, timeScaleVideoPath);
+            allLocalFilePathList.add(timeScaleVideoPath);
+            concatContent.append("file '" + timeScaleVideoPath + "'").append("\n");
+        }
+        return concatContent.toString().trim();
+    }
+
+    private String buildConcatFileContentV2(List<String> clipVideoUrls, List<String> allLocalFilePathList, Integer pretreatmentSwitch) throws Exception {
+        List<String> scaleVideoFilePathList = new ArrayList<>();
+        // 以第一个视频的宽高为准，其他视频宽高不一致，缩放裁剪处理
+        int finalWidth = 720;
+        int finalHeight = 1280;
+        Integer finalAvgFrameRate = null;
+        Integer finalTimeBase = null;
+        for (int i = 0; i < clipVideoUrls.size(); i++) {
+            String clipVideoUrl = clipVideoUrls.get(i);
+            String clipVideoFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+            downloadFile(clipVideoUrl, clipVideoFilePath);
+            allLocalFilePathList.add(clipVideoFilePath);
+            FFmpegUtil.MediaInfo mediaInfo = FFmpegUtil.getMediaInfo(clipVideoFilePath);
+            if (i == 0) {
+                finalWidth = mediaInfo.getWidth();
+                finalHeight = mediaInfo.getHeight();
+                finalAvgFrameRate = mediaInfo.getAvgFrameRate();
+                finalTimeBase = mediaInfo.getTimeBase();
+            }
+            String clipParams = "scale={finalWidth}:{finalHeight}:force_original_aspect_ratio=decrease,pad={finalWidth}:{finalHeight}:(ow-iw)/2:(oh-ih)/2";
+            clipParams = clipParams.replace("{finalWidth}", finalWidth + "").replace("{finalHeight}", finalHeight + "");
+
+            String scaleClipVideoPath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+
+            // 如果开启预处理，且第一个视频的帧率和时间基都有值，则进行预处理
+            if (Objects.equals(pretreatmentSwitch, Constant.INTEGER_TRUE)
+                    && Objects.nonNull(finalAvgFrameRate) && Objects.nonNull(finalTimeBase)) {
+                clipParams = clipParams + ",fps=" + finalAvgFrameRate;
+                FFmpegUtil.clipAndTranscodeVideo(clipVideoFilePath, clipParams, scaleClipVideoPath, finalAvgFrameRate, finalTimeBase);
+            } else {
+                FFmpegUtil.clipAndTranscodeVideo(clipVideoFilePath, clipParams, scaleClipVideoPath, null, null);
+            }
+
+            allLocalFilePathList.add(scaleClipVideoPath);
+
+            scaleVideoFilePathList.add(scaleClipVideoPath);
+
+        }
+        StringBuilder concatContent = new StringBuilder();
+        for (String scaleVideoFilePath : scaleVideoFilePathList) {
+            concatContent.append("file '" + scaleVideoFilePath + "'").append("\n");
+        }
+        return concatContent.toString().trim();
+    }
+
+    @Override
+    public String videoAddTail(VideoAddTailParam param) {
+        long beginTime = System.currentTimeMillis();
+        List<String> allLocalFilePathList = new ArrayList<>();
+        try {
+            String originVideoFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+            downloadFile(param.getOriginVideoUrl(), originVideoFilePath);
+            long time1 = System.currentTimeMillis();
+            log.info("videoAddTail,bizId:{},time1:{}", param.getBizId(), time1 - beginTime);
+            allLocalFilePathList.add(originVideoFilePath);
+            String volumeOriginVideoFilePath = originVideoFilePath;
+            if (Objects.nonNull(param.getOriginVideoVolume())) {
+                long timea = System.currentTimeMillis();
+                String lufsOriginVideoFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+                allLocalFilePathList.add(lufsOriginVideoFilePath);
+                FFmpegUtil.changeVideoVolumeByLoudnorm(originVideoFilePath, "-16", lufsOriginVideoFilePath);
+                long time2 = System.currentTimeMillis();
+                log.info("videoAddTail,bizId:{},time2:{}", param.getBizId(), time2 - timea);
+
+                String volumeMultiple = new BigDecimal(param.getOriginVideoVolume()).divide(new BigDecimal("50"), 2,
+                        RoundingMode.HALF_UP).toString();
+                if (new BigDecimal(volumeMultiple).subtract(new BigDecimal("1.00")).abs().compareTo(new BigDecimal("0.1")) > 0) {
+                    volumeOriginVideoFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+                    allLocalFilePathList.add(volumeOriginVideoFilePath);
+                    FFmpegUtil.changeVideoVolume(lufsOriginVideoFilePath, volumeMultiple, volumeOriginVideoFilePath);
+                } else {
+                    volumeOriginVideoFilePath = lufsOriginVideoFilePath;
+                }
+                long time3 = System.currentTimeMillis();
+                log.info("videoAddTail,bizId:{},time3:{}", param.getBizId(), time3 - time2);
+            }
+            FFmpegUtil.MediaInfo originVideoMediaInfo = FFmpegUtil.getMediaInfo(volumeOriginVideoFilePath);
+
+            List<String> concatFilePathList = new ArrayList<>();
+            concatFilePathList.add(volumeOriginVideoFilePath);
+            if ("video".equals(param.getTailType())) {
+                long timea = System.currentTimeMillis();
+                int finalWidth = originVideoMediaInfo.getWidth();
+                int finalHeight = originVideoMediaInfo.getHeight();
+
+                String tailVideoFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+                allLocalFilePathList.add(tailVideoFilePath);
+                downloadFile(param.getTailVideoUrl(), tailVideoFilePath);
+                String volumeTailVideoFilePath = tailVideoFilePath;
+                if (Objects.nonNull(param.getTailVolume())) {
+                    String lufsTailVideoFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+                    allLocalFilePathList.add(lufsTailVideoFilePath);
+                    FFmpegUtil.changeVideoVolumeByLoudnorm(tailVideoFilePath, "-16", lufsTailVideoFilePath);
+
+                    String volumeMultiple = new BigDecimal(param.getTailVolume()).divide(new BigDecimal("50"), 2,
+                            RoundingMode.HALF_UP).toString();
+                    if (new BigDecimal(volumeMultiple).subtract(new BigDecimal("1.00")).abs().compareTo(new BigDecimal("0.1")) > 0) {
+                        volumeTailVideoFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+                        allLocalFilePathList.add(volumeTailVideoFilePath);
+                        FFmpegUtil.changeVideoVolume(lufsTailVideoFilePath, volumeMultiple, volumeTailVideoFilePath);
+                    } else {
+                        volumeTailVideoFilePath = lufsTailVideoFilePath;
+                    }
+                }
+
+                FFmpegUtil.MediaInfo tailVideoMediaInfo = FFmpegUtil.getMediaInfo(volumeTailVideoFilePath);
+                if (tailVideoMediaInfo.getWidth() == finalWidth && tailVideoMediaInfo.getHeight() == finalHeight) {
+                    concatFilePathList.add(volumeTailVideoFilePath);
+                } else {
+                    String clipParams = buildScaleClipParams(finalWidth, finalHeight, tailVideoMediaInfo.getWidth(),
+                            tailVideoMediaInfo.getHeight());
+                    String scaleClipVideoPath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+                    allLocalFilePathList.add(scaleClipVideoPath);
+                    FFmpegUtil.clipVideo(volumeTailVideoFilePath, clipParams, scaleClipVideoPath);
+                    concatFilePathList.add(scaleClipVideoPath);
+                }
+                long time4 = System.currentTimeMillis();
+                log.info("videoAddTail,bizId:{},time4:{}", param.getBizId(), time4 - timea);
+            } else if ("lastFrame".equals(param.getTailType())) {
+                long timea = System.currentTimeMillis();
+                // 最后一帧图片
+                String lastFrameFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/image/" + BaseUtils.getUUIDStr() + ".png");
+                allLocalFilePathList.add(lastFrameFilePath);
+                int lastTime = 1;
+                int durationSecond = originVideoMediaInfo.getDuration() / 1000;
+                for (int i = 0; i < 100; i++) {
+                    FFmpegUtil.getVideoLastFrame(volumeOriginVideoFilePath, lastTime, lastFrameFilePath);
+                    File lastFrameFile = new File(lastFrameFilePath);
+                    if (lastFrameFile.exists()) {
+                        break;
+                    }
+                    lastTime = lastTime + 3;
+                    if (lastTime >= durationSecond) {
+                        break;
+                    }
+                }
+                long time5 = System.currentTimeMillis();
+                log.info("videoAddTail,bizId:{},time5:{}", param.getBizId(), time5 - timea);
+                File lastFrameFile = new File(lastFrameFilePath);
+                if (!lastFrameFile.exists()) {
+                    throw new CommonException(ExceptionEnum.SYSTEM_ERROR.getCode(), "提取尾帧图片失败");
+                }
+
+                // 确定片尾视频时长
+                Integer audioMillisDuration = 0;
+                String tailAudioFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/audio/" + BaseUtils.getUUIDStr() + ".mp3");
+                String volumeTailAudioFilePath = tailAudioFilePath;
+                FFmpegUtil.MediaInfo tailAudioMediaInfo = null;
+                if (StringUtils.hasText(param.getTailAudioUrl())) {
+                    allLocalFilePathList.add(tailAudioFilePath);
+                    downloadFile(param.getTailAudioUrl(), tailAudioFilePath);
+
+                    if (Objects.nonNull(param.getTailVolume())) {
+                        String lufsTailAudioFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/audio/" + BaseUtils.getUUIDStr() + ".mp3");
+                        allLocalFilePathList.add(lufsTailAudioFilePath);
+                        FFmpegUtil.changeMediaVolumeByLoudnorm(tailAudioFilePath, "-16", lufsTailAudioFilePath);
+
+                        String volumeMultiple = new BigDecimal(param.getTailVolume()).divide(new BigDecimal("50"), 2,
+                                RoundingMode.HALF_UP).toString();
+                        if (new BigDecimal(volumeMultiple).subtract(new BigDecimal("1.00")).abs().compareTo(new BigDecimal("0.1")) > 0) {
+                            volumeTailAudioFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/audio/" + BaseUtils.getUUIDStr() + ".mp3");
+                            allLocalFilePathList.add(volumeTailAudioFilePath);
+                            FFmpegUtil.changeMediaVolume(lufsTailAudioFilePath, volumeMultiple, volumeTailAudioFilePath);
+                        } else {
+                            volumeTailAudioFilePath = lufsTailAudioFilePath;
+                        }
+                    }
+
+                    tailAudioMediaInfo = FFmpegUtil.getMediaInfo(volumeTailAudioFilePath);
+                    audioMillisDuration = tailAudioMediaInfo.getDuration();
+                }
+                long time6 = System.currentTimeMillis();
+                log.info("videoAddTail,bizId:{},time6:{}", param.getBizId(), time6 - time5);
+                Integer srtMillisDuration = param.getSrtMillisDuration();
+                if (Objects.isNull(srtMillisDuration)) {
+                    srtMillisDuration = 0;
+                }
+                Integer tailMillisDuration = Math.max(audioMillisDuration, srtMillisDuration);
+                if (tailMillisDuration == 0) {
+                    tailMillisDuration = 3000;
+                }
+
+                String tailSecondDuration = new BigDecimal(tailMillisDuration).divide(new BigDecimal(1000), 3,
+                        RoundingMode.HALF_UP).toString();
+                // 生成片尾视频
+                String tailVideoFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+                allLocalFilePathList.add(tailVideoFilePath);
+                FFmpegUtil.imageToVideo(lastFrameFilePath, originVideoMediaInfo.getWidth(),
+                        originVideoMediaInfo.getHeight(), tailSecondDuration, tailVideoFilePath);
+                long time7 = System.currentTimeMillis();
+                log.info("videoAddTail,bizId:{},time7:{}", param.getBizId(), time7 - time6);
+
+                // 片尾视频加音频
+                String lastTailVideoFilePath = tailVideoFilePath;
+                if (StringUtils.hasText(param.getTailAudioUrl())) {
+                    String addAudioFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+                    allLocalFilePathList.add(addAudioFilePath);
+                    FFmpegUtil.addAudio(tailVideoFilePath, volumeTailAudioFilePath, addAudioFilePath);
+                    lastTailVideoFilePath = addAudioFilePath;
+                }
+                long time8 = System.currentTimeMillis();
+                log.info("videoAddTail,bizId:{},time8:{}", param.getBizId(), time8 - time7);
+
+                // 片尾视频加字幕
+                if (StringUtils.hasText(param.getAssSubtitle())) {
+                    String assSubtitleFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/subtitle/" + BaseUtils.getUUIDStr() + ".ass");
+                    FileUtils.saveFileContent(assSubtitleFilePath, param.getAssSubtitle().getBytes());
+                    allLocalFilePathList.add(assSubtitleFilePath);
+                    String inputSubtitleAndStyle = "subtitles=" + assSubtitleFilePath;
+                    String addSubtitleFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+                    allLocalFilePathList.add(addSubtitleFilePath);
+                    FFmpegUtil.addSubtitle(lastTailVideoFilePath, inputSubtitleAndStyle, addSubtitleFilePath);
+                    lastTailVideoFilePath = addSubtitleFilePath;
+                }
+                concatFilePathList.add(lastTailVideoFilePath);
+                long time9 = System.currentTimeMillis();
+                log.info("videoAddTail,bizId:{},time9:{}", param.getBizId(), time9 - time8);
+            }
+
+            long timea = System.currentTimeMillis();
+            // 处理视频时间戳，避免拼接后时长不对问题
+            StringBuilder concatContent = new StringBuilder();
+            for (String concatFilePath : concatFilePathList) {
+                String timeFixVideoPath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+                allLocalFilePathList.add(timeFixVideoPath);
+                FFmpegUtil.encodingEquivalence(concatFilePath, timeFixVideoPath);
+                concatContent.append("file '" + timeFixVideoPath + "'").append("\n");
+//                concatContent.append("file '" + concatFilePath + "'").append("\n");
+            }
+            long time10 = System.currentTimeMillis();
+            log.info("videoAddTail,bizId:{},time10:{}", param.getBizId(), time10 - timea);
+            String concatFileListPath = FFmpegUtil.pathCreate("./datalog/videoComposite/filelist/" + BaseUtils.getUUIDStr() + ".txt");
+            FileUtils.saveFileContent(concatFileListPath, concatContent.toString().trim().getBytes());
+            allLocalFilePathList.add(concatFileListPath);
+
+            String concatVideoFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+            allLocalFilePathList.add(concatVideoFilePath);
+            // 拼接视频
+            FFmpegUtil.concatVideos(concatFileListPath, concatVideoFilePath);
+            long time11 = System.currentTimeMillis();
+            log.info("videoAddTail,bizId:{},time11:{}", param.getBizId(), time11 - time10);
+
+            // 拼接完成后再进行一次编码
+//            String outputFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+//            FFmpegUtil.videoTranscoding(concatVideoFilePath, "libx264", outputFilePath);
+//            allLocalFilePathList.add(outputFilePath);
+
+            // 上传到oss中
+            String ossKey = "videoComposite/" + BaseUtils.getUUIDStr() + ".mp4";
+            InputStream inputStream = new FileInputStream(concatVideoFilePath);
+            AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, inputStream, "video/mp4");
+            long time12 = System.currentTimeMillis();
+            log.info("videoAddTail,bizId:{},time12:{}", param.getBizId(), time12 - time11);
+            String result = CdnUtil.getOssHttpUrl(ossKey);
+            log.info("videoAddTail,bizId:{},result:{}", param.getBizId(), result);
+            return result;
+        } catch (Exception e) {
+            log.error("videoAddTail error,param:{}", JSON.toJSONString(param), e);
+            throw new CommonException(ExceptionEnum.SYSTEM_ERROR.getCode(), e.getMessage());
+        } finally {
+            if (CollectionUtil.isNotEmpty(allLocalFilePathList)) {
+                for (String filePath : allLocalFilePathList) {
+                    try {
+                        File file = new File(filePath);
+                        file.delete();
+                    } catch (Exception e) {
+                        log.error("delete file error,", filePath);
+                    }
+                }
+            }
+        }
+    }
+
+    private String buildScaleClipParams(int finalWidth, int finalHeight, int width, int height) {
+        double wRate =
+                new BigDecimal(finalWidth).divide(new BigDecimal(width), 4, RoundingMode.HALF_UP).doubleValue();
+        double hRate =
+                new BigDecimal(finalHeight).divide(new BigDecimal(height), 4, RoundingMode.HALF_UP).doubleValue();
+        String clipParams;
+        if (wRate >= hRate) {
+            int cropX = 0;
+            int targetHeight = (finalWidth * height) / width;
+            if (targetHeight % 2 != 0) {
+                targetHeight = targetHeight + 1;
+            }
+            int cropY = (targetHeight - finalHeight) / 2;
+            if (cropY < 0) {
+                cropY = 0;
+            }
+            clipParams =
+                    "scale=" + finalWidth + ":" + targetHeight + ",crop=" + finalWidth + ":" + finalHeight + ":" + cropX +
+                            ":" + cropY;
+        } else {
+            int targetWidth = (finalHeight * width) / height;
+            if (targetWidth % 2 != 0) {
+                targetWidth = targetWidth + 1;
+            }
+            int cropX = (targetWidth - finalWidth) / 2;
+            if (cropX < 0) {
+                cropX = 0;
+            }
+            int cropY = 0;
+            clipParams =
+                    "scale=" + targetWidth + ":" + finalHeight + ",crop=" + finalWidth + ":" + finalHeight + ":" + cropX +
+                            ":" + cropY;
+        }
+        return clipParams;
+    }
+
+    private String getCutTime(Integer keyFrameTime) {
+        Integer second = (keyFrameTime / 1000) % 60;
+        Integer minute = (keyFrameTime / (1000 * 60)) % 60;
+        Integer hour = (keyFrameTime / (1000 * 60 * 60));
+        return hour + ":" + (minute < 10 ? "0" + minute : minute) + ":" + (second < 10 ? "0" + second : second);
+    }
+
+    @Override
+    public String videoTranscoding(VideoTranscodingParam param) {
+        List<String> allLocalFilePathList = new ArrayList<>();
+        try {
+
+            String originVideoFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+            downloadFile(param.getVideoUrl(), originVideoFilePath);
+            allLocalFilePathList.add(originVideoFilePath);
+
+            String outputFilePath = FFmpegUtil.pathCreate("./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4");
+            allLocalFilePathList.add(outputFilePath);
+
+            FFmpegUtil.videoTranscoding(originVideoFilePath, param.getCoding(), param.getBitrate(), outputFilePath);
+
+            // 上传到oss中
+            String ossKey = "videoComposite/" + BaseUtils.getUUIDStr() + ".mp4";
+            InputStream inputStream = new FileInputStream(outputFilePath);
+            AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, inputStream, "video/mp4");
+            return CdnUtil.getOssHttpUrl(ossKey);
+        } catch (Exception e) {
+            log.error("videoTranscoding error,param:{}", JSON.toJSONString(param), e);
+            throw new CommonException(ExceptionEnum.SYSTEM_ERROR.getCode(), e.getMessage());
+        } finally {
+            if (CollectionUtil.isNotEmpty(allLocalFilePathList)) {
+                for (String filePath : allLocalFilePathList) {
+                    try {
+                        File file = new File(filePath);
+                        file.delete();
+                    } catch (Exception e) {
+                        log.error("delete file error,", filePath);
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public String videoAddAudio(VideoAddAudioParam param) {
+        List<String> allLocalFilePathList = new ArrayList<>();
+        try {
+            // 先判断下视频文件大小，文件太大可能会导致OOM
+            long videoSize = getVideoSize(param.getVideoUrl());
+            if (videoSize > 500 * 1024 * 1024) {
+                throw new CommonException(ExceptionEnum.SYSTEM_ERROR.getCode(), "视频文件太大，不能超过500M");
+            }
+            String videoFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4";
+            downloadFile(param.getVideoUrl(), videoFilePath);
+            allLocalFilePathList.add(videoFilePath);
+            String volumeVideoFilePath = videoFilePath;
+            if (Objects.nonNull(param.getVideoVolume()) && Boolean.TRUE.equals(param.getKeepVideoOriginalSound())) {
+                String lufsVideoFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4";
+                allLocalFilePathList.add(lufsVideoFilePath);
+                FFmpegUtil.changeVideoVolumeByLoudnorm(videoFilePath, "-16", lufsVideoFilePath);
+
+                String volumeMultiple = new BigDecimal(param.getVideoVolume()).divide(new BigDecimal("50"), 2,
+                        RoundingMode.HALF_UP).toString();
+                if (new BigDecimal(volumeMultiple).subtract(new BigDecimal("1.00")).abs().compareTo(new BigDecimal("0.1")) > 0) {
+                    volumeVideoFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4";
+                    allLocalFilePathList.add(volumeVideoFilePath);
+                    FFmpegUtil.changeVideoVolume(lufsVideoFilePath, volumeMultiple, volumeVideoFilePath);
+                } else {
+                    volumeVideoFilePath = lufsVideoFilePath;
+                }
+            }
+
+            String audioFilePath = "./datalog/videoComposite/audio/" + BaseUtils.getUUIDStr() + ".mp3";
+            downloadFile(param.getAudioUrl(), audioFilePath);
+            allLocalFilePathList.add(audioFilePath);
+            String volumeAudioFilePath = audioFilePath;
+            if (Objects.nonNull(param.getAudioVolume())) {
+                String lufsAudioFilePath = "./datalog/videoComposite/audio/" + BaseUtils.getUUIDStr() + ".mp3";
+                allLocalFilePathList.add(lufsAudioFilePath);
+                FFmpegUtil.changeMediaVolumeByLoudnorm(audioFilePath, "-16", lufsAudioFilePath);
+
+                String volumeMultiple = new BigDecimal(param.getAudioVolume()).divide(new BigDecimal("50"), 2,
+                        RoundingMode.HALF_UP).toString();
+                if (new BigDecimal(volumeMultiple).subtract(new BigDecimal("1.00")).abs().compareTo(new BigDecimal("0.1")) > 0) {
+                    volumeAudioFilePath = "./datalog/videoComposite/audio/" + BaseUtils.getUUIDStr() + ".mp3";
+                    allLocalFilePathList.add(volumeAudioFilePath);
+                    FFmpegUtil.changeMediaVolume(lufsAudioFilePath, volumeMultiple, volumeAudioFilePath);
+                } else {
+                    volumeAudioFilePath = lufsAudioFilePath;
+                }
+            }
+
+            String outputFilePath = "./datalog/videoComposite/video/" + BaseUtils.getUUIDStr() + ".mp4";
+
+            if (StringUtils.hasText(param.getMainTimeline()) && "audio".equals(param.getMainTimeline())) {
+                FFmpegUtil.MediaInfo videoMediaInfo = FFmpegUtil.getMediaInfo(volumeVideoFilePath);
+                FFmpegUtil.MediaInfo audioMediaInfo = FFmpegUtil.getMediaInfo(volumeAudioFilePath);
+                int loopCount = audioMediaInfo.getDuration() / videoMediaInfo.getDuration() - 1;
+                if (loopCount >= 0) {
+                    int mod = audioMediaInfo.getDuration() % videoMediaInfo.getDuration();
+                    if (mod > 0) {
+                        loopCount++;
+                    }
+                }
+                if (loopCount < 0) {
+                    loopCount = 0;
+                }
+                if (Boolean.TRUE.equals(param.getKeepVideoOriginalSound())) {
+                    FFmpegUtil.videoAmixAudioLoopVideoAndShortest(volumeVideoFilePath, volumeAudioFilePath, outputFilePath, loopCount);
+                } else {
+                    FFmpegUtil.addAudioLoopVideoAndShortest(volumeVideoFilePath, volumeAudioFilePath, outputFilePath, loopCount);
+                }
+            } else if (StringUtils.hasText(param.getMainTimeline()) && "video".equals(param.getMainTimeline())) {
+                FFmpegUtil.MediaInfo videoMediaInfo = FFmpegUtil.getMediaInfo(volumeVideoFilePath);
+                FFmpegUtil.MediaInfo audioMediaInfo = FFmpegUtil.getMediaInfo(volumeAudioFilePath);
+                int loopCount = videoMediaInfo.getDuration() / audioMediaInfo.getDuration() - 1;
+                if (loopCount >= 0) {
+                    int mod = videoMediaInfo.getDuration() % audioMediaInfo.getDuration();
+                    if (mod > 0) {
+                        loopCount++;
+                    }
+                }
+                if (loopCount < 0) {
+                    loopCount = 0;
+                }
+                if (Boolean.TRUE.equals(param.getKeepVideoOriginalSound())) {
+                    FFmpegUtil.videoAmixAudioLoopAudioAndShortest(volumeVideoFilePath, volumeAudioFilePath, outputFilePath, loopCount);
+                } else {
+                    FFmpegUtil.addAudioLoopAudioAndShortest(volumeVideoFilePath, volumeAudioFilePath, outputFilePath, loopCount);
+                }
+            } else {
+                if (Boolean.TRUE.equals(param.getKeepVideoOriginalSound())) {
+                    FFmpegUtil.videoAmixAudio(volumeVideoFilePath, volumeAudioFilePath, outputFilePath);
+                } else {
+                    FFmpegUtil.addAudio(volumeVideoFilePath, volumeAudioFilePath, outputFilePath);
+                }
+            }
+            allLocalFilePathList.add(outputFilePath);
+            // 上传到oss中
+            String ossKey = "videoComposite/" + BaseUtils.getUUIDStr() + ".mp4";
+            InputStream inputStream = new FileInputStream(outputFilePath);
+            AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), ossKey, inputStream, "video/mp4");
+            return CdnUtil.getOssHttpUrl(ossKey);
+        } catch (Exception e) {
+            log.error("videoAddAudio error,param:{}", JSON.toJSONString(param), e);
+            throw new CommonException(ExceptionEnum.SYSTEM_ERROR.getCode(), e.getMessage());
+        } finally {
+            if (CollectionUtil.isNotEmpty(allLocalFilePathList)) {
+                for (String filePath : allLocalFilePathList) {
+                    try {
+                        File file = new File(filePath);
+                        file.delete();
+                    } catch (Exception e) {
+                        log.error("delete file error,", filePath);
+                    }
+                }
+            }
+        }
+    }
+
+    private long getVideoSize(String url) {
+        HttpResponseContent hrc = HttpClientUtils.head(url);
+        long videoSize = 0;
+        for (Header header : hrc.getHeaders()) {
+            if ("content-length".equals(header.getName().toLowerCase())) {
+                videoSize = Long.valueOf(header.getValue());
+                break;
+            }
+        }
+        return videoSize;
+    }
+
+    private int extractNumber(String filename) {
+        int lastUnderscore = filename.lastIndexOf('_');
+        if (lastUnderscore != -1 && lastUnderscore < filename.length() - 1) {
+            try {
+                String numberStr = filename.substring(lastUnderscore + 1);
+                return Integer.parseInt(numberStr);
+            } catch (NumberFormatException e) {
+                // 忽略解析错误
+            }
+        }
+        return Integer.MAX_VALUE;
+    }
+
+}

src/main/java/com/tzld/ffmpeg/service/impl/ImageServiceImpl.java

@@ -0,0 +1,420 @@
+package com.tzld.ffmpeg.service.impl;
+
+import cn.hutool.core.collection.CollectionUtil;
+import com.stuuudy.commons.external.filestorage.enums.EnumPublicBuckets;
+import com.tzld.ffmpeg.exception.DownloadImageError;
+import com.tzld.ffmpeg.exception.SplicingImageError;
+import com.tzld.ffmpeg.model.dto.SplicingImageDTO;
+import com.tzld.ffmpeg.model.param.DiverseSplicingImageParam;
+import com.tzld.ffmpeg.model.param.SimpleSplicingImageParam;
+import com.tzld.ffmpeg.service.ImageService;
+import com.tzld.ffmpeg.util.*;
+import lombok.extern.slf4j.Slf4j;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+import org.apache.http.util.TextUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.util.Pair;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+
+import javax.imageio.ImageIO;
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
+
+@Component
+@Slf4j
+public class ImageServiceImpl implements ImageService {
+    public static final String OSS_LAYER_KEY_PREFIX = "layer/";
+    public static final String OSS_SPLICING_KEY_PREFIX = "splicing/";
+
+    @Autowired
+    RedisUtils redisUtils;
+
+    private static final OkHttpClient okHttpClient = new OkHttpClient.Builder()
+            .connectTimeout(10, TimeUnit.SECONDS)
+            .readTimeout(60, TimeUnit.SECONDS)
+            .writeTimeout(15, TimeUnit.SECONDS)
+            .build();
+
+    @Override
+    public String imageLayer(String imageUrl, Float alpha) {
+        return imageLayer(imageUrl, null, alpha);
+    }
+
+    @Override
+    public String imageLayer(String imageUrl, String imageType, Float alpha) {
+        final String cacheKeyPrefix = "layer";
+        try {
+            // 检查是否有处理过的缓存
+            String url = redisUtils.get(cacheKeyPrefix + imageUrl);
+            if (StringUtils.hasText(url)) {
+                return url;
+            }
+
+            byte[] bytes = ImageUtils.layer(
+                    imageUrl,
+                    imageType,
+                    Optional.ofNullable(alpha).orElse(0.01f)
+            );
+            String key = OSS_LAYER_KEY_PREFIX + DistributedIdGenerator.generate() + ".jpg";
+            AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), key, new ByteArrayInputStream(bytes));
+            url = CdnUtil.getOssHttpUrl(key);
+            redisUtils.set(cacheKeyPrefix + imageUrl, url, 24 * 60 * 60);
+            return url;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public byte[] imageDownload(String imageUrl) throws DownloadImageError {
+        try {
+            OkHttpClient client = new OkHttpClient();
+            Request request = new Request.Builder()
+                    .url(CdnUtil.getOssHttpUrl(imageUrl))
+                    .build();
+            try (Response response = client.newCall(request).execute()) {
+                if (response.isSuccessful()) {
+                    return response.body().bytes();
+                }else {
+                    throw new DownloadImageError("图片下载失败，code" + response.code());
+                }
+            }
+        } catch (Exception e) {
+            throw new DownloadImageError(e.getMessage());
+        }
+    }
+
+    @Override
+    public byte[] imageDownloadV2(String imageUrl) throws DownloadImageError {
+        try {
+            Request request = new Request.Builder()
+                    .url(CdnUtil.getOssHttpUrl(imageUrl))
+                    .build();
+            try (Response response = okHttpClient.newCall(request).execute()) {
+                if (response.isSuccessful()) {
+                    return response.body().bytes();
+                }else {
+                    throw new DownloadImageError("图片下载失败，code" + response.code());
+                }
+            }
+        } catch (Exception e) {
+            throw new DownloadImageError(e.getMessage());
+        }
+    }
+
+    @Override
+    public String imageSplicing(List<List<SimpleSplicingImageParam>> inputs) throws SplicingImageError {
+        if (CollectionUtil.isEmpty(inputs)) {
+            throw new SplicingImageError("未输入有效图片");
+        }
+        if (inputs.stream().anyMatch(CollectionUtil::isEmpty)) {
+            throw new SplicingImageError("输入有错误，有行不存在有效图片");
+        }
+
+        // 下载图片
+        List<List<SplicingImageDTO>> images = new ArrayList<>();
+        for (List<SimpleSplicingImageParam> input : inputs) {
+            List<SplicingImageDTO> objects = new ArrayList<>();
+            for (SimpleSplicingImageParam image : input) {
+                try {
+                    byte[] bytes = imageDownload(image.getUrl());
+                    BufferedImage bufferedImage = ImageIO.read(new ByteArrayInputStream(bytes));
+                    objects.add(
+                            new SplicingImageDTO()
+                                    .setImage(bufferedImage)
+                                    .setHeight(Optional.ofNullable(image.getHeight()).orElse(bufferedImage.getHeight()))
+                                    .setWidth(Optional.ofNullable(image.getWidth()).orElse(bufferedImage.getWidth()))
+                    );
+                } catch (DownloadImageError e) {
+                    throw new SplicingImageError("拼接失败，图片下载失败。" + e.getMessage());
+                } catch (IOException e) {
+                    throw new SplicingImageError("拼接失败，创建BufferedImage失败。" + e.getMessage());
+                }
+            }
+            images.add(objects);
+        }
+
+        // 开始拼接
+        byte[] bytes;
+        try {
+            // 计算画布的整体宽、高
+            int width = images
+                    .stream()
+                    .mapToInt(obj -> obj.stream().mapToInt(SplicingImageDTO::getWidth).sum())
+                    .max().getAsInt();
+            int height = 0;
+            int colNum = images
+                    .stream()
+                    .mapToInt(List::size)
+                    .max().getAsInt();
+            for (int i = 0; i < colNum; i++) {
+                int count = 0;
+                for (List<SplicingImageDTO> dtos : images) {
+                    if (dtos.size() > i) {
+                        Integer num = dtos.get(i).getHeight();
+                        count += num;
+                    }
+                }
+                if (count > height) {
+                    height = count;
+                }
+            }
+
+            // 开始画
+            BufferedImage newImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
+            Graphics2D g2d = newImage.createGraphics();
+            int yStart = 0;
+            for (List<SplicingImageDTO> dtos : images) {
+                int x = 0;
+                for (SplicingImageDTO dto : dtos) {
+                    g2d.drawImage(dto.getImage(), x, yStart, dto.getWidth(), dto.getHeight(), null);
+                    x = x + dto.getWidth();
+                }
+                int maxHeight = dtos.stream().mapToInt(SplicingImageDTO::getHeight).max().getAsInt();
+                yStart = yStart + maxHeight;
+            }
+            g2d.dispose();
+            ByteArrayOutputStream os = new ByteArrayOutputStream();
+            ImageIO.write(newImage, "PNG", os);
+            bytes = os.toByteArray();
+        }catch (Exception e) {
+            throw new SplicingImageError("拼接失败。" + e.getMessage());
+        }
+
+        String key = OSS_SPLICING_KEY_PREFIX + DistributedIdGenerator.generate() + ".jpg";
+        AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), key, new ByteArrayInputStream(bytes));
+        return CdnUtil.getOssHttpUrl(key);
+    }
+
+    @Override
+    public String imageSplicing(DiverseSplicingImageParam input) throws SplicingImageError {
+        if (Objects.isNull(input) || CollectionUtil.isEmpty(input.getChildren())) {
+            throw new SplicingImageError("未输入有效图片");
+        }
+        if (Objects.isNull(input.getSize()) || Objects.isNull(input.getSize().getWidth())) {
+            throw new SplicingImageError("未设置拼接后图像大小");
+        }
+
+        // 创建画布
+        BufferedImage newImage = new BufferedImage(input.getSize().getWidth(), input.getSize().getHeight(), BufferedImage.TYPE_INT_ARGB);
+        Graphics2D g2d = newImage.createGraphics();
+        // 设置背景色为白色
+        g2d.setColor(Color.white);
+        g2d.fillRect(0, 0, newImage.getWidth(), newImage.getHeight());
+        // 开始递归画
+        graph(g2d, input, Pair.of(0, 0));
+        g2d.dispose();
+        byte[] bytes;
+        try {
+            ByteArrayOutputStream os = new ByteArrayOutputStream();
+            ImageIO.write(newImage, "PNG", os);
+            bytes = os.toByteArray();
+        }catch (Exception e) {
+            throw new SplicingImageError("拼接失败。" + e.getMessage());
+        }
+        String key = OSS_SPLICING_KEY_PREFIX + DistributedIdGenerator.generate() + ".jpg";
+        AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), key, new ByteArrayInputStream(bytes));
+        return CdnUtil.getOssHttpUrl(key);
+    }
+
+    @Override
+    public byte[] compress(String imageUrl, Integer targetHeight) throws DownloadImageError, IOException {
+        byte[] bytes = imageDownload(imageUrl);
+        BufferedImage bufferedImage = ImageIO.read(new ByteArrayInputStream(bytes));
+        int originalWidth = bufferedImage.getWidth();
+        int originalHeight = bufferedImage.getHeight();
+        if (originalHeight <= targetHeight) {
+            return bytes;
+        }
+
+        int newHeight = targetHeight;
+        int newWidth = (int) (originalWidth * (newHeight / (double) originalHeight));
+
+        BufferedImage outputImage = new BufferedImage(newWidth, newHeight, bufferedImage.getType());
+        Graphics2D g2d = outputImage.createGraphics();
+        g2d.drawImage(bufferedImage, 0, 0, newWidth, newHeight, null);
+        g2d.dispose();
+
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        ImageIO.write(outputImage, "jpg", byteArrayOutputStream);
+        return byteArrayOutputStream.toByteArray();
+    }
+
+    @Override
+    public Pair<Integer, Integer> imageSize(String image) throws DownloadImageError, IOException {
+        byte[] bytes = this.imageDownload(image);
+        BufferedImage bufferedImage = ImageIO.read(new ByteArrayInputStream(bytes));
+        int width = bufferedImage.getWidth();
+        int height = bufferedImage.getHeight();
+        return Pair.of(width, height);
+    }
+
+    @Override
+    public boolean resourceIsAccessible(String url) {
+        OkHttpClient client = new OkHttpClient().newBuilder()
+                .connectTimeout(20, TimeUnit.SECONDS)
+                .readTimeout(40, TimeUnit.SECONDS)
+                .writeTimeout(20, TimeUnit.SECONDS)
+                .build();
+        Request request = new Request.Builder()
+                .url(url)
+                .method("HEAD", null)
+                .build();
+        try {
+            Response response = client.newCall(request).execute();
+            if (response.isSuccessful()) {
+                return true;
+            }
+            return false;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    private Pair<Integer,Integer> graph(Graphics2D g2d, DiverseSplicingImageParam input, Pair<Integer, Integer> nextPosition) throws SplicingImageError{
+        // 对象为布局
+        if (TextUtils.isBlank(input.getImg())) {
+            // row、column
+            String direction = input.getDirection();
+            Integer gap = input.getGap();
+            List<DiverseSplicingImageParam> children = input.getChildren();
+            for (int i = 0; i < children.size(); i++) {
+                Pair<Integer,Integer> latetstPositionPair = graph(g2d, children.get(i), nextPosition);
+                if (i == children.size() - 1) {
+                    return latetstPositionPair;
+                }else {
+                    if (direction.equals("row")) {
+                        nextPosition = Pair.of(nextPosition.getFirst(), latetstPositionPair.getSecond() + gap);
+                    }else {
+                        nextPosition = Pair.of(latetstPositionPair.getFirst() + gap, nextPosition.getSecond());
+                    }
+                }
+            }
+
+            return nextPosition;
+        }else {
+            try {
+                byte[] bytes = imageDownload(input.getImg());
+                BufferedImage bufferedImage = ImageIO.read(new ByteArrayInputStream(bytes));
+                // 先按Position裁切 update 20240805
+                DiverseSplicingImageParam.Position position = input.getPosition();
+                // 裁切区域左上角的X坐标
+                int cropX = position.getLeft().setScale(0, RoundingMode.UP).intValue();
+                // 裁切区域左上角的Y坐标
+                int cropY = position.getTop().setScale(0, RoundingMode.UP).intValue();
+                // 裁切区域的宽度
+                int cropWidth =
+                        bufferedImage.getWidth() - cropX - position.getRight().setScale(0, RoundingMode.UP).intValue();
+                // 裁切区域的高度
+                int cropHeight =
+                        bufferedImage.getHeight() - cropY - position.getBottom().setScale(0, RoundingMode.UP).intValue();
+                // 执行裁切操作
+                bufferedImage = bufferedImage.getSubimage(cropX, cropY, cropWidth, cropHeight);
+
+                int dx1 = nextPosition.getFirst();
+                int dy1 = nextPosition.getSecond();
+                int dx2 = nextPosition.getFirst() + input.getSize().getWidth();
+                int dy2 = nextPosition.getSecond() + input.getSize().getHeight();
+                int sx1 = 0;
+                int sx2 = bufferedImage.getWidth();
+                int sy1 = 0;
+                int sy2 = bufferedImage.getHeight();
+
+                // 等比放大/缩小，切掉多余的高度/宽度，居中切割
+                Image image = bufferedImage;
+                BigDecimal canvasRatio = new BigDecimal(input.getSize().getWidth()).divide(new BigDecimal(input.getSize().getHeight()), 2, RoundingMode.UP);
+                BigDecimal originalRatio = new BigDecimal(image.getWidth(null)).divide(new BigDecimal(image.getHeight(null)), 2, RoundingMode.UP);
+
+                // 这里加步图片缩放，目的是防止单位画布内挤压过多像素点导致图像不清晰
+                if (canvasRatio.compareTo(originalRatio) < 0 && image.getHeight(null) > input.getSize().getHeight()) {
+                    // 以高度为准等比缩放
+                    image = bufferedImage.getScaledInstance(
+                            new BigDecimal(image.getWidth(null))
+                                    .multiply(
+                                            new BigDecimal(input.getSize().getHeight())
+                                                    .divide(new BigDecimal(image.getHeight(null)), 2, RoundingMode.UP)
+                                    ).intValue(),
+                            input.getSize().getHeight(), Image.SCALE_SMOOTH);
+                    sx2 = image.getWidth(null);
+                    sy2 = image.getHeight(null);
+                }else if (canvasRatio.compareTo(originalRatio) > 0 && image.getWidth(null) > input.getSize().getWidth()) {
+                    // 以宽度为准等比缩放
+                    image = bufferedImage.getScaledInstance(
+                            input.getSize().getWidth(),
+                            new BigDecimal(image.getHeight(null))
+                                    .multiply(
+                                            new BigDecimal(input.getSize().getWidth())
+                                                    .divide(new BigDecimal(image.getWidth(null)), 2, RoundingMode.UP)
+                                    ).intValue(), Image.SCALE_SMOOTH);
+                    sx2 = image.getWidth(null);
+                    sy2 = image.getHeight(null);
+                }
+
+                // 要画的宽高比小于原始宽高比,宽度需要截取
+                if (canvasRatio.compareTo(originalRatio) < 0) {
+                    BigDecimal d = new BigDecimal(input.getSize().getHeight())
+                            .divide(new BigDecimal(image.getHeight(null)), 2, RoundingMode.UP);
+                    BigDecimal width = new BigDecimal(input.getSize().getWidth())
+                            .divide(d, 2, RoundingMode.UP);
+                    sx1 = sx1 + (
+                            new BigDecimal(image.getWidth(null)).subtract(width)
+                                    .divide(new BigDecimal(2))
+                                    .intValue()
+                            );
+                    sx2 = sx2 - (
+                            new BigDecimal(image.getWidth(null)).subtract(width)
+                                    .divide(new BigDecimal(2))
+                                    .intValue()
+                            );
+                }else if (canvasRatio.compareTo(originalRatio) > 0) {
+                    // 要画的宽高比小于原始宽高比，高度需要截取
+                    BigDecimal d = new BigDecimal(input.getSize().getWidth())
+                            .divide(new BigDecimal(image.getWidth(null)), 2, RoundingMode.UP);
+                    BigDecimal height = new BigDecimal(input.getSize().getHeight())
+                            .divide(d, 2, RoundingMode.UP);
+                    sy1 = sy1 + (
+                            new BigDecimal(image.getHeight(null)).subtract(height)
+                                    .divide(new BigDecimal(2))
+                                    .intValue()
+                    );
+                    sy2 = sy2 - (
+                            new BigDecimal(image.getHeight(null)).subtract(height)
+                                    .divide(new BigDecimal(2))
+                                    .intValue()
+                    );
+                }
+
+                g2d.drawImage(image,
+                        dx1, dy1,
+                        dx2, dy2,
+                        sx1, sy1, sx2, sy2, null);
+                return Pair.of(nextPosition.getFirst() + input.getSize().getWidth(), nextPosition.getSecond() + input.getSize().getHeight());
+            } catch (DownloadImageError e) {
+                throw new SplicingImageError("拼接失败，图片下载失败。" + e.getMessage());
+            } catch (Exception e) {
+                throw new SplicingImageError("拼接失败，创建BufferedImage失败。" + e.getMessage());
+            }
+        }
+    }
+
+    @Override
+    public String transferAndStore(String imageUrl) throws DownloadImageError {
+        byte[] bytes = this.imageDownload(imageUrl);
+        String key = OSS_LAYER_KEY_PREFIX + DistributedIdGenerator.generate() + ".jpg";
+        AliOssFileTool.saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(), key, new ByteArrayInputStream(bytes));
+        return CdnUtil.getOssHttpUrl(key);
+    }
+}

src/main/java/com/tzld/ffmpeg/util/AliOssFileTool.java

@@ -0,0 +1,1510 @@
+package com.tzld.ffmpeg.util;
+
+import cn.hutool.http.HttpUtil;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.aliyun.opensearch.sdk.dependencies.org.apache.commons.codec.binary.Base64;
+import com.aliyun.oss.*;
+import com.aliyun.oss.common.utils.BinaryUtil;
+import com.aliyun.oss.model.*;
+import com.aliyuncs.DefaultAcsClient;
+import com.aliyuncs.exceptions.ServerException;
+import com.aliyuncs.http.MethodType;
+import com.aliyuncs.http.ProtocolType;
+import com.aliyuncs.mts.model.v20140618.SubmitJobsRequest;
+import com.aliyuncs.mts.model.v20140618.SubmitJobsResponse;
+import com.aliyuncs.mts.model.v20140618.SubmitMediaInfoJobRequest;
+import com.aliyuncs.mts.model.v20140618.SubmitMediaInfoJobResponse;
+import com.aliyuncs.mts.model.v20140618.SubmitMediaInfoJobResponse.MediaInfoJob.Properties;
+import com.aliyuncs.profile.DefaultProfile;
+import com.aliyuncs.profile.IClientProfile;
+import com.aliyuncs.sts.model.v20150401.AssumeRoleRequest;
+import com.aliyuncs.sts.model.v20150401.AssumeRoleResponse;
+import com.stuuudy.commons.external.filestorage.alibaba.OSSFileDO;
+import com.stuuudy.commons.external.filestorage.enums.*;
+import com.stuuudy.commons.util.BlankUtil;
+import com.stuuudy.commons.util.CompressImage;
+import com.stuuudy.commons.util.MD5.Md5Util;
+import com.stuuudy.commons.util.exception.CommonsException;
+import com.stuuudy.commons.util.exception.EnumErrorException;
+import com.tzld.ffmpeg.common.enums.EnumUploadFileType;
+import com.tzld.ffmpeg.config.AliOssConfig;
+import com.tzld.ffmpeg.model.vo.SignatureVO;
+import com.tzld.ffmpeg.model.vo.StsTokenVO;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.log4j.Logger;
+import org.springframework.stereotype.Component;
+
+import javax.crypto.Mac;
+import javax.crypto.SecretKey;
+import javax.crypto.spec.SecretKeySpec;
+import javax.imageio.ImageIO;
+import javax.xml.crypto.dsig.SignatureMethod;
+import java.awt.image.BufferedImage;
+import java.io.*;
+import java.net.URL;
+import java.net.URLEncoder;
+import java.security.DigestInputStream;
+import java.security.InvalidKeyException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.*;
+
+/**
+ * (阿里对象存储工具类)<BR>
+ * AliOssFileTool<BR>
+ * 创建人:陈海 <BR>
+ * 时间：2016年7月18日-下午12:47:52 <BR>
+ *
+ * @version 1.0.0
+ */
+@Component
+@Slf4j
+public class AliOssFileTool extends AliOssConfig {
+
+    private static Logger logger = Logger.getLogger(AliOssFileTool.class);
+
+    private static final String ENCODE_TYPE = "UTF-8";
+    private static final String ALGORITHM = "HmacSHA1";
+    private static final String HTTP_METHOD = "GET";
+    private static final String SEPARATOR = "&";
+    private static final String EQUAL = "=";
+
+    public static String saveInPublicWithPress(InputStream inputStream, EnumPublicBuckets bucket, String key, EnumFileType type,
+                                               EnumFileSuffix fileSuffix) throws OSSException, ClientException {
+        inputStream = compressImg(inputStream, fileSuffix, type);
+        return saveInPublicNoPress(inputStream, bucket, key, type);
+    }
+
+    public static String saveInPublicReturnHost(InputStream inputStream, EnumPublicBuckets bucket, String fullKey,
+                                                EnumFileType type) {
+        String path = saveInPublic(inputStream, bucket, fullKey, type);
+        // 保存路径
+        return CdnUtil.getCdnUrlHost(type) + path;
+    }
+
+    public static String saveInPublic(InputStream inputStream, EnumPublicBuckets bucket, String fullKey, EnumFileType type) {
+        String bucketName = getBucket(bucket.getBucketName());
+        if (EnumFileType.VOICE.equals(type)) {
+            ObjectMetadata om = new ObjectMetadata();
+            om.setContentType("audio/mpeg");
+            getOssClient().putObject(bucketName, fullKey, inputStream, om);
+        } else if (EnumFileType.PICTURE.equals(type)) {
+            ObjectMetadata om = new ObjectMetadata();
+            om.setContentType("image/jpeg");
+            getOssClient().putObject(bucketName, fullKey, inputStream, om);
+        } else if (EnumFileType.VIDEO.equals(type)) {
+            ObjectMetadata om = new ObjectMetadata();
+            om.setContentType("video/mp4");
+            getOssClient().putObject(bucketName, fullKey, inputStream, om);
+        } else {
+            getOssClient().putObject(bucketName, fullKey, inputStream);
+        }
+        return fullKey;
+    }
+
+    public static String saveInPublic(String bucketName, String ossKey, InputStream inputStream, String contentType) {
+        bucketName = getBucket(bucketName);
+        ObjectMetadata om = new ObjectMetadata();
+        om.setContentType(contentType);
+        getOssClient().putObject(bucketName, ossKey, inputStream, om);
+        return ossKey;
+    }
+
+    public static void saveInPublic(String bucketName, String key, InputStream input) {
+        getOssClient().putObject(bucketName, key, input);
+    }
+
+    public static String moveFile(EnumPublicBuckets sourceBucket, String sourceKey, EnumPublicBuckets targetBucket, String targetKey) {
+        getOssClient().copyObject(getBucket(sourceBucket.getBucketName()), sourceKey,
+                getBucket(targetBucket.getBucketName()), targetKey);
+        if (!StringUtils.equals(sourceKey, targetKey)) {
+            getOssClient().deleteObject(getBucket(sourceBucket.getBucketName()), sourceKey);
+        }
+        return targetKey;
+    }
+
+    public static void deleteFile(EnumPublicBuckets bucket, String key) {
+        getOssClient().deleteObject(getBucket(bucket.getBucketName()), key);
+    }
+
+    public static String saveInPublicNoPress(InputStream inputStream, EnumPublicBuckets bucket, String key,
+                                             EnumFileType type) throws OSSException, ClientException {
+        String fullKey = getProjectName() + "/" + type.getLocation() + key;
+        saveInPublic(inputStream, bucket, fullKey, type);
+        return fullKey;
+    }
+
+    /**
+     * (网络资源上传) 方法名saveURLInPublicNoPress
+     *
+     * @param url        资源地址
+     * @param key
+     * @param type
+     * @param fileSuffix
+     * @return
+     * @throws OSSException
+     * @throws ClientException
+     * @throws IOException     String
+     * @throws @version        1.0
+     * @author 创建人：何振斌
+     * @time 创建日期：2018年3月12日 下午7:10:00
+     */
+    public static String saveURLInPublicNoPress(String url, String bucketName, String key, EnumFileType type,
+                                                EnumFileSuffix fileSuffix) throws OSSException, ClientException, IOException {
+        String fullKey = getProjectName() + "/" + type.getLocation() + key;
+        InputStream inputStream = null;
+        if (!BlankUtil.isBlank(url)) {
+            inputStream = new URL(url).openStream();
+        }
+        if (EnumFileType.VOICE.equals(type)) {
+            ObjectMetadata om = new ObjectMetadata();
+            om.setContentType("audio/mpeg");
+            getOssClient().putObject(bucketName, fullKey, inputStream, om);
+        } else {
+            getOssClient().putObject(bucketName, fullKey, inputStream);
+        }
+        return getProjectName() + "/" + type.getLocation() + key;
+    }
+
+    /**
+     * (根据名称和类型保存文件,返回是否成功)<BR>
+     * 方法名：saveWiteKeyAndType<BR>
+     * 创建人：陈海 <BR>
+     * 时间：2016年7月18日-下午1:02:10 <BR>
+     *
+     * @param inputStream 文件流
+     * @param bucket      空间名称
+     * @param key         文件保存在服务器上的另存名
+     * @param type        枚举文件类型，声音或图片等
+     * @return boolean<BR>
+     * @throws IOException
+     * @throws ClientException
+     * @throws OSSException
+     * @throws <BR>
+     * @since 1.0.0
+     */
+    public static boolean saveInPrivate(InputStream inputStream, EnumPrivateBuckets bucket, String key,
+                                        EnumFileType type, EnumFileSuffix suffix) throws OSSException, ClientException, IOException {
+        inputStream = compressImg(inputStream, suffix, type);
+        String bucketName = getBucket(bucket.getBucketName());
+        String fullKey = getProjectName() + "/" + type.getLocation() + key;
+        getOssClient().putObject(bucketName, fullKey, inputStream);
+        return true;
+    }
+
+    /**
+     * (获取前缀为prefix的全部文件)<BR>
+     * 方法名：listFileInFolder<BR>
+     * 创建人：陈海 <BR>
+     * 时间：2017年1月20日-下午4:59:25 <BR>
+     *
+     * @param bucket
+     * @param prefix
+     * @return List<OSSObjectSummary><BR>
+     * @throws <BR>
+     * @since 1.0.0
+     */
+    public static List<OSSObjectSummary> listFileInFolder(EnumPublicBuckets bucket, String prefix) {
+        final int maxKeys = 200;
+        String nextMarker = null;
+        ObjectListing objectListing;
+        List<OSSObjectSummary> sums = new ArrayList<OSSObjectSummary>();
+        // 递归列出fun目录下的所有文件
+        do {
+            ListObjectsRequest listObjectsRequest = new ListObjectsRequest(getBucket(bucket.getBucketName()));
+            listObjectsRequest.setPrefix(prefix);
+            listObjectsRequest.withMarker(nextMarker).withMaxKeys(maxKeys);
+            objectListing = getOssClient().listObjects(listObjectsRequest);
+            List<OSSObjectSummary> temp = objectListing.getObjectSummaries();
+            if (temp != null) {
+                sums.addAll(temp);
+            }
+            nextMarker = objectListing.getNextMarker();
+        } while (objectListing.isTruncated());
+        return sums;
+    }
+
+    /**
+     * (判断是否存在文件)<BR>
+     * 方法名：isExist<BR>
+     * 创建人：陈海 <BR>
+     * 时间：2016年11月21日-下午3:54:36 <BR>
+     *
+     * @param bucket
+     * @param key
+     * @param type
+     * @return boolean<BR>
+     * @throws <BR>
+     * @since 1.0.0
+     */
+    public static boolean isExist(EnumPrivateBuckets bucket, String key, EnumFileType type) {
+        String fullKey = getProjectName() + "/" + type.getLocation() + key;
+        return getOssClient().doesObjectExist(getBucket(bucket.getBucketName()), fullKey);
+    }
+
+    public static final String REGION_CN_HANGZHOU = "cn-hangzhou";
+    public static final String STS_API_VERSION = "2015-04-01";
+
+    public static AssumeRoleResponse getTempUserToken(long durationSeconds, Integer uid)
+            throws com.aliyuncs.exceptions.ClientException {
+
+        // 只有 RAM用户（子账号）才能调用 AssumeRole 接口
+        // 阿里云主账号的AccessKeys不能用于发起AssumeRole请求
+        // 请首先在RAM控制台创建一个RAM用户，并为这个用户创建AccessKeys
+        String accessKeyId = "LTAIQLkVvDFXRO7j";
+        String accessKeySecret = "aOnxO0xyoa0lDmTxTI1cNmVLNotF15";
+
+        // RoleArn 需要在 RAM 控制台上获取
+        String roleArn = "acs:ram::1894469520484605:role/aliyunosstokengeneratorrole";
+        String policy = JSONObject.toJSONString(AliOssFileTool.getPolicyDetail());
+        // RoleSessionName 是临时Token的会话名称，自己指定用于标识你的用户，主要用于审计，或者用于区分Token颁发给谁
+        // 但是注意RoleSessionName的长度和规则，不要有空格，只能有'-' '_' 字母和数字等字符
+        // 具体规则请参考API文档中的格式要求
+        String roleSessionName = "uid_" + uid;
+
+        // 此处必须为 HTTPS
+        ProtocolType protocolType = ProtocolType.HTTPS;
+
+        try {
+            final AssumeRoleResponse stsResponse = assumeRole(accessKeyId, accessKeySecret, roleArn, roleSessionName,
+                    policy, protocolType, durationSeconds);
+            return stsResponse;
+            /*
+             * Map<String, String> respMap = new LinkedHashMap<String, String>();
+             * respMap.put("status", "200"); respMap.put("AccessKeyId",
+             * stsResponse.getCredentials().getAccessKeyId());
+             * respMap.put("AccessKeySecret",
+             * stsResponse.getCredentials().getAccessKeySecret());
+             * respMap.put("SecurityToken",
+             * stsResponse.getCredentials().getSecurityToken()); respMap.put("Expiration",
+             * stsResponse.getCredentials().getExpiration());
+             */
+
+        } catch (ClientException e) {
+            throw e;
+        }
+
+    }
+
+    protected static AssumeRoleResponse assumeRole(String accessKeyId, String accessKeySecret, String roleArn,
+                                                   String roleSessionName, String policy, ProtocolType protocolType, long durationSeconds)
+            throws com.aliyuncs.exceptions.ClientException {
+        try {
+            // 创建一个 Aliyun Acs Client, 用于发起 OpenAPI 请求
+            IClientProfile profile = DefaultProfile.getProfile(REGION_CN_HANGZHOU, accessKeyId, accessKeySecret);
+            DefaultAcsClient client = new DefaultAcsClient(profile);
+
+            // 创建一个 AssumeRoleRequest 并设置请求参数
+            final AssumeRoleRequest request = new AssumeRoleRequest();
+            request.setVersion(STS_API_VERSION);
+            request.setMethod(MethodType.POST);
+            request.setProtocol(protocolType);
+
+            request.setRoleArn(roleArn);
+            request.setRoleSessionName(roleSessionName);
+            request.setPolicy(policy);
+            request.setDurationSeconds(durationSeconds);
+
+            // 发起请求，并得到response
+            final AssumeRoleResponse response = client.getAcsResponse(request);
+
+            return response;
+        } catch (com.aliyuncs.exceptions.ClientException e) {
+            throw e;
+        }
+    }
+
+    /**
+     * (判断是否存在文件)<BR>
+     * 方法名：isExist<BR>
+     * 创建人：陈海 <BR>
+     * 时间：2016年11月21日-下午3:54:36 <BR>
+     *
+     * @param bucket
+     * @param key
+     * @param type
+     * @return boolean<BR>
+     * @throws <BR>
+     * @since 1.0.0
+     */
+    @Deprecated
+    public boolean isExist(EnumPublicBuckets bucket, String key, EnumFileType type) {
+        String fullKey = getProjectName() + "/" + type.getLocation() + key;
+        return getOssClient().doesObjectExist(getBucket(bucket.getBucketName()), fullKey);
+    }
+
+    /**
+     * (用bucket名称和完整key 判断文件是否存在)<BR>
+     * 方法名：isExist<BR>
+     * 创建人：陈海 <BR>
+     * 时间：2017年5月12日-下午6:38:49 <BR>
+     *
+     * @param bucket
+     * @param fullKey
+     * @return boolean<BR>
+     * @throws <BR>
+     * @since 1.0.0
+     */
+    public static boolean isExist(String bucket, String fullKey) {
+        return getOssClient().doesObjectExist(bucket, fullKey);
+    }
+
+    /**
+     * 文件是否存在 内网
+     *
+     * @param bucket
+     * @param fullKey
+     * @return
+     */
+    public static boolean isExistOfInternal(String bucket, String fullKey) {
+        return getInternalOssClient().doesObjectExist(bucket, fullKey);
+    }
+
+    /**
+     * (删除oss文件)<BR>
+     * 方法名：delFile<BR>
+     * 创建人：陈海 <BR>
+     * 时间：2016年7月20日-上午10:44:52 <BR>
+     *
+     * @param bucket 存储空间名称
+     * @param key    文件保存在服务器上的另存名
+     * @param type   枚举文件类型，声音或图片等
+     * @return boolean<BR>
+     * @throws <BR>
+     * @since 1.0.0
+     */
+    public static boolean delFile(EnumAllBuckets bucket, String key, EnumFileType type) {
+        getOssClient().deleteObject(getBucket(bucket.getBucketName()),
+                getProjectName() + "/" + type.getLocation() + key);
+        return true;
+    }
+
+    public static boolean deleteObject(String bucketName, String objectKey) {
+        getInternalOssClient().deleteObject(bucketName, objectKey);
+        return true;
+    }
+
+    public static boolean deleteObjects(String bucketName, List<String> objectKeys) {
+        if (objectKeys == null || objectKeys.size() == 0) {
+            return false;
+        }
+        DeleteObjectsRequest deleteObjectsRequest = new DeleteObjectsRequest(bucketName);
+        deleteObjectsRequest.setKeys(objectKeys);
+        deleteObjectsRequest.setQuiet(true);
+        getInternalOssClient().deleteObjects(deleteObjectsRequest);
+        return true;
+    }
+
+    /**
+     * (获取经处理的图片签名url)<BR>
+     * 方法名：getPicUrlWithSign<BR>
+     * 创建人：陈海 <BR>
+     * 时间：2016年7月18日-下午1:07:23 <BR>
+     *
+     * @param bucket 空间名称
+     * @param key    文件保存在服务器上的名称
+     * @param type   枚举文件类型，声音或图片等
+     * @return String<BR>
+     * @throws <BR>
+     * @since 1.0.0
+     */
+    public static String getPicUrl(EnumPrivateBuckets bucket, String key, EnumFileType type, Long expiresSec) {
+        if (expiresSec == null) {
+            expiresSec = getExpiration();
+        }
+        Date expires = new Date(new Date().getTime() + getExpiration() * 1000);
+        String picUrl = getPriClient().generatePresignedUrl(getBucket(bucket.getBucketName()),
+                getProjectName() + "/" + type.getLocation() + key, expires).toString();
+        return picUrl;
+    }
+
+    /**
+     * (获取文件对象的签名url)<BR>
+     * 方法名：getUrlWithSign<BR>
+     * 创建人：陈海 <BR>
+     * 时间：2016年7月18日-下午1:05:50 <BR>
+     *
+     * @param bucket 空间名称
+     * @param key    文件保存在服务器上的名称
+     * @param type   枚举文件类型，声音或图片等
+     * @return String<BR>
+     * @throws <BR>
+     * @since 1.0.0
+     */
+    public static String getUrl(EnumPrivateBuckets bucket, String key, EnumFileType type, Long expiresSec) {
+        if (expiresSec == null) {
+            expiresSec = getExpiration();
+        }
+        Date expires = new Date(new Date().getTime() + expiresSec * 1000);
+        String url = "";
+        if (type.equals(EnumFileType.VIDEO)) {
+            url = getVideoClient().generatePresignedUrl(getBucket(bucket.getBucketName()),
+                    getProjectName() + "/" + type.getLocation() + key, expires).toString();
+        } else {
+            url = getPriClient().generatePresignedUrl(getBucket(bucket.getBucketName()),
+                    getProjectName() + "/" + type.getLocation() + key, expires).toString();
+        }
+        return url;
+    }
+
+    public static String getUrlWithOssEndPoint(EnumPrivateBuckets bucket, String key, EnumFileType type,
+                                               Long expiresSec) {
+        if (expiresSec == null) {
+            expiresSec = getExpiration();
+        }
+        Date expires = new Date(new Date().getTime() + expiresSec * 1000);
+        return getOssClient().generatePresignedUrl(getBucket(bucket.getBucketName()),
+                getProjectName() + "/" + type.getLocation() + key, expires).toString();
+    }
+
+    /**
+     * (获取object)<BR>
+     * 方法名：getObject<BR>
+     * 创建人：陈海 <BR>
+     * 时间：2016年12月28日-上午10:55:43 <BR>
+     *
+     * @param bucket
+     * @param key
+     * @param type
+     * @return OSSObject<BR>
+     * @throws <BR>
+     * @since 1.0.0
+     */
+    public static OSSObject getObject(EnumPrivateBuckets bucket, String key, EnumFileType type) {
+        OSSObject ossObject = getOssClient().getObject(getBucket(bucket.getBucketName()),
+                getProjectName() + "/" + type.getLocation() + key);
+        return ossObject;
+    }
+
+    public static OSSObject getPubObject(EnumAllBuckets bucket, String key, EnumFileType type) {
+        OSSObject ossObject = getOssClient().getObject(getBucket(bucket.getBucketName()),
+                getProjectName() + "/" + type.getLocation() + key);
+        return ossObject;
+    }
+
+    public static OSSObject getPubObject(String bucketName, String fullKey) {
+        OSSObject ossObject = getOssClient().getObject(bucketName, fullKey);
+        return ossObject;
+    }
+
+    public static OSSObject getInternalPubObject(String bucketName, String fullKey) {
+        OSSObject ossObject = getInternalOssClient().getObject(bucketName, fullKey);
+        return ossObject;
+    }
+
+    public static ObjectMetadata getPubObjectMedeta(EnumAllBuckets bucket, String key, EnumFileType type) {
+        ObjectMetadata ossObjectMeta = getOssClient().getObjectMetadata(getBucket(bucket.getBucketName()),
+                getProjectName() + "/" + type.getLocation() + key);
+        return ossObjectMeta;
+    }
+
+    public static String calcFileMD5(String bucketName, String objectKey) {
+        try {
+            OSSObject ossObj = getOssClient().getObject(bucketName, objectKey);
+            MessageDigest md = MessageDigest.getInstance("MD5");
+            try (DigestInputStream digestInputStream = new DigestInputStream(ossObj.getObjectContent(), md)) {
+                // 读取数据流并更新 MD5
+                byte[] buffer = new byte[8192];
+                while (digestInputStream.read(buffer) != -1) {
+                    // DigestInputStream 会自动更新 MessageDigest
+                }
+            } catch (Exception e) {
+                logger.info("读取oss文件异常: ", e);
+                return "";
+            }
+
+            // 获取最终的 MD5 值
+            byte[] md5Bytes = md.digest();
+            // 转换为十六进制字符串
+            StringBuilder sb = new StringBuilder();
+            for (byte b : md5Bytes) {
+                sb.append(String.format("%02x", b));
+            }
+
+            String md5 = sb.toString();
+            logger.info(String.format("buketName: %s, objectKey: %s, MD5: %s", bucketName, objectKey, md5));
+
+            return md5;
+        } catch (Exception e) {
+            logger.error("计算文件MD5异常: ", e);
+        }
+        return "";
+    }
+
+    /**
+     * (重命名文件，实现是先拷贝文件，再删掉旧的文件)<BR>
+     * 方法名：renameFile<BR>
+     * 创建人：陈海 <BR>
+     * 时间：2016年8月1日-下午4:03:09 <BR>
+     *
+     * @param srcBucket
+     * @param srckey
+     * @param destkey
+     * @return boolean<BR>
+     * @throws <BR>
+     * @since 1.0.0
+     */
+    @Deprecated
+    public boolean renameFile(EnumAllBuckets srcBucket, String srckey, String destkey, EnumFileType srcType,
+                              EnumFileType destType) {
+
+        // 拷贝Object
+        getOssClient().copyObject(getBucket(srcBucket.getBucketName()),
+                getProjectName() + "/" + srcType.getLocation() + srckey, getBucket(srcBucket.getBucketName()),
+                getProjectName() + "/" + destType.getLocation() + destkey);
+        delFile(srcBucket, srckey, srcType);
+        return true;
+    }
+
+    /**
+     * (将oss srckey 命名为 destkey)<BR>
+     * 方法名：renameFileWithFullKey<BR>
+     * 创建人：陈海 <BR>
+     * 时间：2017年9月16日-下午5:24:39 <BR>
+     *
+     * @param srcBucket
+     * @param srckey
+     * @param destkey
+     * @return boolean<BR>
+     * @throws <BR>
+     * @since 1.0.0
+     */
+    public static boolean renameFileWithFullKey(EnumAllBuckets srcBucket, String srckey, String destkey) {
+
+        // 拷贝Object
+        getOssClient().copyObject(getBucket(srcBucket.getBucketName()), srckey, getBucket(srcBucket.getBucketName()),
+                destkey);
+        getOssClient().deleteObject(getBucket(srcBucket.getBucketName()), srckey);
+        return true;
+    }
+
+    public static boolean renameFileWithFullKeyFromInternal(EnumAllBuckets srcBucket, String srckey, String destkey, long size) {
+        // 拷贝Object
+        if (size < 1024 * 1024 * 1024) {
+            getInternalOssClient().copyObject(getBucket(srcBucket.getBucketName()), srckey,
+                    getBucket(srcBucket.getBucketName()), destkey);
+        } else {
+            multipartCopyObjectFromInternal(getBucket(srcBucket.getBucketName()), srckey,
+                    getBucket(srcBucket.getBucketName()), destkey);
+        }
+        getInternalOssClient().deleteObject(getBucket(srcBucket.getBucketName()), srckey);
+        return true;
+    }
+
+    // 分片拷贝object,大于1G的文件需要分片拷贝
+    public static void multipartCopyObjectFromInternal(String sourceBucketName, String sourceObjectName,
+                                                       String destinationBucketName, String destinationObjectName) {
+        OSSClient ossClient = getInternalOssClient();
+        ObjectMetadata objectMetadata = ossClient.getObjectMetadata(sourceBucketName, sourceObjectName);
+        // 获取被拷贝文件的大小。
+        long contentLength = objectMetadata.getContentLength();
+
+        // 设置分片大小为10MB。
+        long partSize = 1024 * 1024 * 10;
+
+        // 计算分片总数。
+        int partCount = (int) (contentLength / partSize);
+        if (contentLength % partSize != 0) {
+            partCount++;
+        }
+        logger.info("oss 分片拷贝开始,sourceObjectName:" + sourceObjectName + ",size:" + contentLength + ",partCount:" + partCount);
+        // 初始化拷贝任务。可以通过InitiateMultipartUploadRequest指定目标文件元信息。
+        InitiateMultipartUploadRequest initiateMultipartUploadRequest = new InitiateMultipartUploadRequest(
+                destinationBucketName, destinationObjectName);
+        InitiateMultipartUploadResult initiateMultipartUploadResult = ossClient
+                .initiateMultipartUpload(initiateMultipartUploadRequest);
+        String uploadId = initiateMultipartUploadResult.getUploadId();
+
+        // 分片拷贝。
+        List<PartETag> partETags = new ArrayList<PartETag>();
+        for (int i = 0; i < partCount; i++) {
+            // 计算每个分片的大小。
+            long skipBytes = partSize * i;
+            long size = partSize < contentLength - skipBytes ? partSize : contentLength - skipBytes;
+
+            // 创建UploadPartCopyRequest。可以通过UploadPartCopyRequest指定限定条件。
+            UploadPartCopyRequest uploadPartCopyRequest = new UploadPartCopyRequest(sourceBucketName, sourceObjectName,
+                    destinationBucketName, destinationObjectName);
+            uploadPartCopyRequest.setUploadId(uploadId);
+            uploadPartCopyRequest.setPartSize(size);
+            uploadPartCopyRequest.setBeginIndex(skipBytes);
+            uploadPartCopyRequest.setPartNumber(i + 1);
+            UploadPartCopyResult uploadPartCopyResult = ossClient.uploadPartCopy(uploadPartCopyRequest);
+
+            // 将返回的分片ETag保存到partETags中。
+            partETags.add(uploadPartCopyResult.getPartETag());
+        }
+
+        // 提交分片拷贝任务。
+        CompleteMultipartUploadRequest completeMultipartUploadRequest = new CompleteMultipartUploadRequest(
+                destinationBucketName, destinationObjectName, uploadId, partETags);
+        ossClient.completeMultipartUpload(completeMultipartUploadRequest);
+        logger.info("oss 分片拷贝结束,sourceObjectName:" + sourceObjectName + ",size:" + contentLength + ",partCount:" + partCount);
+    }
+
+    public static void copyObject(String srcBucketName, String srcObjectKey,
+                                  String destBucketName, String destObjectKey) {
+        getOssClient().copyObject(srcBucketName, srcObjectKey, destBucketName, destObjectKey);
+    }
+
+    public static void copyObjectFromInternal(String srcBucketName, String srcObjectKey,
+                                              String destBucketName, String destObjectKey) {
+        getInternalOssClient().copyObject(srcBucketName, srcObjectKey, destBucketName, destObjectKey);
+    }
+
+    private static InputStream compressImg(InputStream stream, EnumFileSuffix suffix, EnumFileType fileType) {
+        if (!getNeedPress()) {
+            return stream;
+        }
+        if (suffix == EnumFileSuffix.JPG || suffix == EnumFileSuffix.PNG || suffix == EnumFileSuffix.JPEG
+                || suffix == EnumFileSuffix.BMP) {
+            try {
+                byte[] file = CompressImage.compress(stream, 1080);
+                if (file != null) {
+                    stream = new ByteArrayInputStream(file);
+                } else {
+                    logger.warn("图片上传有误");
+                    return null;
+                }
+            } catch (Exception e) {
+                logger.error("图片压缩失败", e);
+                if (null != stream) {
+                    try {
+                        stream.close();
+                    } catch (IOException e1) {
+                    }
+                }
+                throw new CommonsException(EnumErrorException.PIC_FORMAT_ERROR);
+            }
+        }
+        return stream;
+    }
+
+    public static String submitPubTranscodeJob(EnumPublicBuckets inputBucket, EnumAllBuckets outputBucket,
+                                               String fullKey, String outPutKey, String templateId) {
+        OSSFileDO inputFile = new OSSFileDO(OSS_REGION, getBucket(EnumAllBuckets.PUBVIDEOBUCKET.getBucketName()),
+                fullKey);
+        JSONArray outputs = new JSONArray();
+        JSONObject outPutConfig = new JSONObject();
+        outPutConfig.put("OutputObject", outPutKey);
+        outPutConfig.put("TemplateId", templateId);
+        outputs.add(outPutConfig);
+        SubmitJobsRequest request = new SubmitJobsRequest();
+        request.setInput(inputFile.toJsonString());
+        request.setOutputs(outputs.toJSONString());
+        request.setPipelineId(PIPELINEID);
+        request.setOutputBucket(getBucket(outputBucket.getBucketName()));
+        request.setOutputLocation(OSS_REGION);
+        Integer outputJobCount = 1;
+
+        SubmitJobsResponse response = null;
+        try {
+            response = getDefaultAcsClient().getAcsResponse(request);
+            if (response.getJobResultList().size() != outputJobCount) {
+                throw new RuntimeException("SubmitJobsRequest Size failed");
+            }
+            return response.getJobResultList().get(0).getJob().getJobId();
+        } catch (ServerException e) {
+            logger.error("submitTranscodeJob Server failed", e);
+            throw new CommonsException(EnumErrorException.TRANS_CODE_SERVER_ERROR);
+        } catch (com.aliyuncs.exceptions.ClientException e) {
+            logger.error("submitTranscodeJob Client failed", e);
+            throw new CommonsException(EnumErrorException.TRANS_CODE_CLIENT_ERROR);
+        }
+    }
+
+    public static String getPubPicAverageColor(EnumAllBuckets bucket, String key) {
+        String style = "image/average-hue";
+        try {
+            GetObjectRequest request = new GetObjectRequest(getBucket(bucket.getBucketName()), key);
+            request.setProcess(style);
+            OSSObject obj = getOssClient().getObject(request);
+            if (obj != null) {
+                String a = IOUtils.toString(obj.getObjectContent());
+                JSONObject jo = (JSONObject) JSONObject.parse(a);
+                String rgb = jo.getString("RGB");
+                if (rgb != null) {
+                    rgb = rgb.replace("0x", "#");
+                }
+                return rgb;
+            }
+        } catch (Exception e) {
+            throw new CommonsException(EnumErrorException.TRANS_CODE_CLIENT_ERROR);
+        }
+        return null;
+    }
+
+    public static Properties getPubObjMediaInfoData(String bucketName, String fullKey) {
+        DefaultAcsClient client = getDefaultAcsClient();
+        SubmitMediaInfoJobRequest request = new SubmitMediaInfoJobRequest();
+        request.setReadTimeout(Integer.MAX_VALUE);
+        SubmitMediaInfoJobResponse response = new SubmitMediaInfoJobResponse();
+        JSONObject json = new JSONObject();
+        json.put("Location", "oss-cn-hangzhou");
+        json.put("Bucket", bucketName);
+        json.put("Object", fullKey);
+        request.setInput(json.toJSONString());
+        try {
+            response = client.getAcsResponse(request);
+            // String width = response.getMediaInfoJob().getProperties().getWidth();
+            // String height = response.getMediaInfoJob().getProperties().getHeight();
+            return response.getMediaInfoJob().getProperties();
+
+        } catch (Exception e) {
+            throw new CommonsException(EnumErrorException.TRANS_CODE_CLIENT_ERROR, e);
+        }
+    }
+
+    public static SignatureVO getUploadPolicy(Integer fileType) throws Exception {
+        // 后台随机生成唯一文件名
+        String env = PropertiesUtils.getProjectEnv();
+        if (StringUtils.isEmpty(env)) {
+            env = "qa";
+        }
+        String fileName = RandomUtil.generate18String();
+        String contentType = "";
+        if (EnumUploadFileType.VIDEO.getIntType().equals(fileType)) {
+            fileName = "/video/" + env + "/" + DateUtils.dateToStringyyyyMMdd(new Date()) + "/" + fileName;
+        } else if (EnumUploadFileType.VOICE.getIntType().equals(fileType)) {
+            fileName = "/voice/" + env + "/" + DateUtils.dateToStringyyyyMMdd(new Date()) + "/" + fileName;
+        } else {
+            fileName = "/pic/" + env + "/" + DateUtils.dateToStringyyyyMMdd(new Date()) + "/" + fileName;
+        }
+        long expireTime = 60 * 60 * 4;
+        long expireEndTime = System.currentTimeMillis() + expireTime * 1000;
+        Date expiration = new Date(expireEndTime);
+        PolicyConditions policyConds = new PolicyConditions();
+        //4.95G  上限是5个G
+        policyConds.addConditionItem(PolicyConditions.COND_CONTENT_LENGTH_RANGE, 0, 5261334938l);
+        policyConds.addConditionItem(MatchMode.Exact, PolicyConditions.COND_KEY,
+                AliOssConfig.getProjectName() + fileName);
+        if (!StringUtils.isEmpty(contentType)) {
+            policyConds.addConditionItem(PolicyConditions.COND_CONTENT_TYPE, contentType);
+        }
+
+        String postPolicy = AliOssConfig.getOssClient().generatePostPolicy(expiration, policyConds);
+        byte[] binaryData = postPolicy.getBytes("utf-8");
+        String encodedPolicy = BinaryUtil.toBase64String(binaryData);
+        String postSignature = AliOssConfig.getOssClient().calculatePostSignature(postPolicy);
+        SignatureVO signatureVO = new SignatureVO();
+        signatureVO.setAccessId(AliOssConfig.getAccessKeyId());
+        signatureVO.setPolicy(encodedPolicy);
+        signatureVO.setSignature(postSignature);
+        signatureVO.setFileName(AliOssConfig.getProjectName() + fileName);
+        signatureVO.setHost(AliOssConfig.getUploadDomain());
+        signatureVO.setExpire(String.valueOf(expireEndTime / 1000));
+        return signatureVO;
+    }
+
+    public static String getSignaturedUrl(String fileName, Boolean isPrivate) {
+
+        if (StringUtils.isBlank(fileName)) {
+            return fileName;
+        }
+        if (StringUtils.startsWith(fileName, "https")) {
+            return fileName;
+        }
+        String host = AliOssConfig.getVideoDomain();
+        fileName = host + fileName;
+        return fileName;
+    }
+
+    public static String getSignaturedInternalUrl(String fileName, Boolean isPrivate) throws Exception {
+        if (StringUtils.isBlank(fileName)) {
+            return fileName;
+        }
+        if (StringUtils.startsWith(fileName, "https")) {
+            return fileName;
+        }
+        String bucket = getBucket(isPrivate);
+        String host = "http://" + bucket + "." + AliOssConfig.getInternalEndPoint();
+        fileName = host + "/" + fileName;
+        return fileName;
+    }
+
+    public static String saveVideoCoverImagFromInternal(File file, Integer fileType, Boolean isPrivate, Long videoId)
+            throws Exception {
+        Date begin = new Date();
+        logger.info(String.format("开始往阿里云OSS上传封面图片,当前时间为:%s", begin.getTime()));
+        String bucketName = getBucket(isPrivate);
+
+        String fullKey = getVideoCoverImagPath(fileType, isPrivate, videoId.toString(), null);
+        AliOssConfig.getInternalOssClient().putObject(bucketName, fullKey, file);
+        Date end = new Date();
+        logger.info(String.format("阿里云OSS上传封面图片完成，总耗时为 %s 毫秒。图片地址为：%s， 正在执行下一步。。", end.getTime() - begin.getTime(),
+                fullKey));
+        return fullKey;
+    }
+
+    public static String saveVideoCoverImagFromInternal(InputStream input, Integer fileType, Boolean isPrivate,
+                                                        String filePrex, String dic) throws Exception {
+        Date begin = new Date();
+        logger.info(String.format("开始往阿里云OSS上传图片,当前时间为:%s", begin.getTime()));
+        String bucketName = getBucket(isPrivate);
+
+        String fullKey = getVideoCoverImagPath(fileType, isPrivate, filePrex, dic);
+        // AliOssConfig.getOssClient().putObject(bucketName, fullKey, file);
+        AliOssConfig.getInternalOssClient().putObject(bucketName, fullKey, input);
+        Date end = new Date();
+        logger.info(
+                String.format("阿里云OSS上传图片完成，总耗时为 %s 毫秒。图片地址为：%s， 正在执行下一步。。", end.getTime() - begin.getTime(), fullKey));
+        return fullKey;
+    }
+
+    public static String getVideoCoverImagPath(Integer fileType, Boolean isPrivate, String filePrex, String dic)
+            throws Exception {
+        String fileName = UUID.randomUUID().toString().replaceAll("-", "") + Calendar.getInstance().getTimeInMillis()
+                + "_" + filePrex;
+        if (StringUtils.isNotBlank(dic)) {
+            fileName = (dic + "/" + fileName);
+        }
+        if (EnumUploadFileType.VIDEO.getIntType().equals(fileType)) {
+            fileName = "/video/" + fileName;
+        } else if (EnumUploadFileType.VOICE.getIntType().equals(fileType)) {
+            fileName = "/voice/" + fileName;
+        } else {
+            fileName = "/pic/" + fileName;
+        }
+        String fullKey = AliOssConfig.getProjectName() + fileName;
+        return fullKey;
+    }
+
+    public static String getBucket(boolean isPrivate) {
+        if (isPrivate) {
+            return AliOssFileTool.getBucket(EnumAllBuckets.PRIVIDEOBUCKET.getBucketName());
+        } else {
+            return AliOssFileTool.getBucket(EnumAllBuckets.PUBVIDEOBUCKET.getBucketName());
+        }
+    }
+
+    public static ObjectMetadata getObjectMetadata(String fileName) throws Exception {
+
+        // Endpoint以杭州为例，其它Region请按实际情况填写。
+        // 创建OSSClient实例。
+        OSSClient ossClient = new OSSClient(AliOssConfig.getInternalEndPoint(), AliOssConfig.getAccessKeyId(),
+                AliOssConfig.getAccessKeySecret());
+        // // 获取文件的部分元信息。
+        // SimplifiedObjectMeta objectMeta = ossClient.getSimplifiedObjectMeta(
+        // getBucket(false), fileName);
+        // logger.info( "SimplifiedObjectMeta==="+ JSON.toJSONString(objectMeta));
+        // 获取文件的全部元信息。
+        ObjectMetadata metadata = ossClient.getObjectMetadata(getBucket(false), fileName);
+        // logger.info( "metadata==="+ JSON.toJSONString(metadata));
+        return metadata;
+    }
+
+    /**
+     * 获取部分元信息
+     *
+     * @param bucketName
+     * @param fileName
+     * @return
+     * @throws Exception
+     */
+    public static SimplifiedObjectMeta getSimpleObjectMetadata(String bucketName, String fileName) throws Exception {
+        OSS ossClient = new OSSClientBuilder().build(AliOssConfig.getInternalEndPoint(), AliOssConfig.getAccessKeyId(),
+                AliOssConfig.getAccessKeySecret());
+        SimplifiedObjectMeta metadata = ossClient.getSimplifiedObjectMeta(bucketName, fileName);
+        ossClient.shutdown();
+        return metadata;
+    }
+
+    /**
+     * 获取全部元信息
+     *
+     * @param bucketName
+     * @param fileName
+     * @return
+     * @throws Exception
+     */
+    public static ObjectMetadata getObjectMetadata(String bucketName, String fileName) throws Exception {
+//		OSS ossClient = new OSSClientBuilder().build(AliOssConfig.getInternalEndPoint(), AliOssConfig.getAccessKeyId(),
+//				AliOssConfig.getAccessKeySecret());
+//		// 获取文件的全部元信息
+//		ObjectMetadata metadata = ossClient.getObjectMetadata(bucketName, fileName);
+//		ossClient.shutdown();
+//		return metadata;
+        ObjectMetadata metadata = getInternalOssClient().getObjectMetadata(bucketName, fileName);
+        return metadata;
+    }
+
+//    public static void main(String[] args) throws Exception {
+////		String a = JSONObject.toJSONString(AliOssFileTool.getDefaultAcsClient());
+////		System.out.println(a);
+//    }
+
+    public static Map<String, String> buildCommonParameters() {
+        Map<String, String> parameterMap = new HashMap<>();
+        // 请求公共参数
+        parameterMap.put("Version", "2014-06-18");
+        parameterMap.put("AccessKeyId", AliOssConfig.getAccessKeyId()); // 此处请替换成您自己的AccessKeyId
+        // parameterMap.put("Timestamp",
+        // "2018-07-27T13:03:45Z");//此处将时间戳固定只是测试需要，这样此示例中生成的签名值就不会变，方便您对比验证，可变时间戳的生成需要用下边这句替换
+        parameterMap.put("Timestamp", DateUtils.formatIso8601Date(new Date()));
+        parameterMap.put("SignatureMethod", "HMAC-SHA1");
+        parameterMap.put("SignatureVersion", "1.0");
+        // parameterMap.put("SignatureNonce", "4902260a-516a-4b6a-a455-45b653cf6150");
+        // //此处将唯一随机数固定只是测试需要，这样此示例中生成的签名值就不会变，方便您对比验证，可变唯一随机数的生成需要用下边这句替换
+        parameterMap.put("SignatureNonce", UUID.randomUUID().toString());
+        parameterMap.put("Format", "JSON"); // 另外支持JSON格式
+        return parameterMap;
+    }
+
+    /**
+     * @Title: sendAsyncSnapshotJob @Description: 获取发送视频批量截图的任务的URL，此接口为异步任务 @param
+     * fileName 要截图的视频的路径，如 longvideo/video/XXXXX，其中XXXXX为视频名称 @param
+     * snapshotPath 截图后的图片输出路径，如
+     * longvideo/snapshot/XXXXX,截图时会自动在文件名后面加序号,输出路径为空时，自动指定为longvideo/snapshot/XXXXX @param
+     * startMillseconds 截图时间，单位毫秒 @param interval
+     * 截图间隔时间，若指定则表示异步模式序列截图，Interval必须大于等于0，默认10，单位秒。其中Interval=0表示根据视频时长平均截图。 @param
+     * snapshotNumber
+     * 截图数量，若指定则表示异步模式序列截图，且必须大于0,当Time＋Interval＊Num的截取点超过视频时长时，后续截图自动失效，截图完成时返回实际截取的个数;当Num=1，忽略Interval参数，表示异步单张截图 @return @throws
+     * Exception @author 王树杞 @date 2018年7月27日 下午5:17:31 @version 2.0 @throws
+     */
+    public static String sendAsyncSnapshotJob(String fileName, String snapshotPath, Integer startMillseconds,
+                                              Integer interval, Integer snapshotNumber) throws Exception {
+
+        // 首先获取公众参数
+        Map<String, String> parameterMap = buildCommonParameters();
+        parameterMap.put("Action", "SubmitSnapshotJob");
+
+        Map<String, String> inputParamsMap = new HashMap<>();
+        inputParamsMap.put("Bucket", AliOssFileTool.getBucket(false));
+        inputParamsMap.put("Location", AliOssFileTool.getSnapshotLocation());
+        inputParamsMap.put("Object", URLEncoder.encode(fileName, "UTF-8"));
+        parameterMap.put("Input", JSON.toJSONString(inputParamsMap));
+        Map<String, String> snapshotConfig = new HashMap<>();
+        Map<String, String> outPutFile = new HashMap<>();
+        outPutFile.put("Bucket", AliOssFileTool.getBucket(false));
+        outPutFile.put("Location", AliOssFileTool.getSnapshotLocation());
+        if (StringUtils.isBlank(snapshotPath)) {
+            snapshotPath = fileName.replace("/video/", "/snapshot/");
+        }
+        outPutFile.put("Object", URLEncoder.encode(snapshotPath + "_{Count}", "UTF-8"));
+        snapshotConfig.put("Interval", interval.toString());
+        snapshotConfig.put("Num", snapshotNumber.toString());
+        parameterMap.put("PipelineId", "abe6a0b9b9334858913eb416974485d2");
+
+        snapshotConfig.put("OutputFile", JSON.toJSONString(outPutFile));
+        parameterMap.put("SnapshotConfig", JSON.toJSONString(snapshotConfig));
+
+        String canonicalizedQueryString = buildCanonicalizedQueryString(parameterMap);
+        String stringToSign = buildStringToSign(canonicalizedQueryString);
+        String signature = buildSignature(AliOssConfig.getAccessKeySecret(), stringToSign);
+
+        return buildRequestURL(signature, parameterMap);
+
+    }
+
+    /**
+     * @Title: sendSyncSnapshotJob @Description: 获取发送某个视频的同步截图的任务URL地址 @param
+     * fileName 视频路径 @param snapshotPath 输出的截图路径 @param startMillseconds
+     * 截图的时间戳 @return 某个视频的同步截图的任务URL地址 @throws Exception @author 王树杞 @date
+     * 2018年7月27日 下午8:07:47 @version 2.0 @throws
+     */
+    public static String sendSyncSnapshotJob(String fileName, String snapshotPath, Integer startMillseconds)
+            throws Exception {
+
+        // 首先获取公众参数
+        Map<String, String> parameterMap = buildCommonParameters();
+        parameterMap.put("Action", "SubmitSnapshotJob");
+
+        Map<String, String> inputParamsMap = new HashMap<>();
+        inputParamsMap.put("Bucket", AliOssFileTool.getBucket(false));
+        inputParamsMap.put("Location", AliOssFileTool.getSnapshotLocation());
+        inputParamsMap.put("Object", URLEncoder.encode(fileName, "UTF-8"));
+        parameterMap.put("Input", JSON.toJSONString(inputParamsMap));
+        Map<String, String> snapshotConfig = new HashMap<>();
+        Map<String, String> outPutFile = new HashMap<>();
+        outPutFile.put("Bucket", AliOssFileTool.getBucket(false));
+        outPutFile.put("Location", AliOssFileTool.getSnapshotLocation());
+        if (StringUtils.isBlank(snapshotPath)) {
+            snapshotPath = fileName.replace("/video/", "/snapshot/");
+        }
+        outPutFile.put("Object", URLEncoder.encode(snapshotPath, "UTF-8"));
+        snapshotConfig.put("Time", startMillseconds.toString());
+        snapshotConfig.put("OutputFile", JSON.toJSONString(outPutFile));
+        parameterMap.put("SnapshotConfig", JSON.toJSONString(snapshotConfig));
+
+        String canonicalizedQueryString = buildCanonicalizedQueryString(parameterMap);
+        String stringToSign = buildStringToSign(canonicalizedQueryString);
+        String signature = buildSignature(AliOssConfig.getAccessKeySecret(), stringToSign);
+
+        return buildRequestURL(signature, parameterMap);
+
+    }
+
+    private static String percentEncode(String value) throws UnsupportedEncodingException {
+        return URLEncoder.encode(value, ENCODE_TYPE).replace("+", "%20").replace("*", "%2A").replace("%7E", "~");
+    }
+
+    private static String buildCanonicalizedQueryString(Map<String, String> parameterMap)
+            throws UnsupportedEncodingException {
+        // 对参数进行排序
+        List<String> sortedKeys = new ArrayList<String>(parameterMap.keySet());
+        Collections.sort(sortedKeys);
+        StringBuilder temp = new StringBuilder();
+        for (String key : sortedKeys) {
+            // 此处需要对key和value进行编码
+            String value = parameterMap.get(key);
+            temp.append(SEPARATOR).append(percentEncode(key)).append(EQUAL).append(percentEncode(value));
+        }
+        return temp.toString().substring(1);
+    }
+
+    private static String buildStringToSign(String canonicalizedQueryString) throws UnsupportedEncodingException {
+        // 生成stringToSign字符
+        StringBuilder temp = new StringBuilder();
+        temp.append(HTTP_METHOD).append(SEPARATOR);
+        temp.append(percentEncode("/")).append(SEPARATOR);
+        // 此处需要对canonicalizedQueryString进行编码
+        temp.append(percentEncode(canonicalizedQueryString));
+        return temp.toString();
+    }
+
+    private static String buildSignature(String keySecret, String stringToSign)
+            throws UnsupportedEncodingException, InvalidKeyException, NoSuchAlgorithmException {
+        SecretKey key = new SecretKeySpec((keySecret + SEPARATOR).getBytes(ENCODE_TYPE), SignatureMethod.HMAC_SHA1);
+        Mac mac = Mac.getInstance(ALGORITHM);
+        mac.init(key);
+        byte[] hashBytes = mac.doFinal(stringToSign.toString().getBytes(ENCODE_TYPE));
+        byte[] base64Bytes = new Base64().encode(hashBytes);
+        String base64UTF8String = new String(base64Bytes, "utf-8");
+        return URLEncoder.encode(base64UTF8String, ENCODE_TYPE);
+    }
+
+    private static String buildRequestURL(String signature, Map<String, String> parameterMap)
+            throws UnsupportedEncodingException {
+        // 生成请求URL
+        StringBuilder temp = new StringBuilder("http://mts.cn-hangzhou.aliyuncs.com?");
+        temp.append(URLEncoder.encode("Signature", ENCODE_TYPE)).append("=").append(signature);
+        for (Map.Entry<String, String> e : parameterMap.entrySet()) {
+            temp.append("&").append(percentEncode(e.getKey())).append("=").append(percentEncode(e.getValue()));
+        }
+        return temp.toString();
+    }
+
+    public static String saveInputStreamPic(InputStream inputStream, String bucket, String project, String dir,
+                                            String key) throws OSSException, ClientException, IOException {
+        String fullKey = project + "/" + dir + "/" + key;
+        ObjectMetadata objectMetadata = new ObjectMetadata();
+        objectMetadata.setContentType("image/jpg");
+        getOssClient().putObject(bucket, fullKey, inputStream, objectMetadata);
+        return fullKey;
+    }
+
+    public static String sendImageToAliOss(BufferedImage image) throws Exception {
+
+        ByteArrayOutputStream os = new ByteArrayOutputStream();
+        ImageIO.write(image, "jpg", os);
+        InputStream is = new ByteArrayInputStream(os.toByteArray());
+        // 将生成的图片往OSS里面上传
+        String random = UUID.randomUUID().toString().replaceAll("-", "") + new Random().nextLong();
+        String key = Md5Util.encoderByMd5(random);
+        String coverImgPath = AliOssFileTool.saveVideoCoverImagFromInternal(is, key);
+        return coverImgPath;
+    }
+
+    public static String saveVideoCoverImagFromInternal(InputStream inputStream, String key)
+            throws OSSException, ClientException, IOException {
+        String bucketName = AliOssConfig.getBucket(EnumAllBuckets.PUBVIDEOBUCKET.getBucketName());
+        String fullKey = getProjectName() + "/pic/video/cover/" + DateUtils.dateToStringyyyyMMdd(new Date()) + "/"
+                + key;
+        ObjectMetadata objectMetadata = new ObjectMetadata();
+        objectMetadata.setContentType("image/jpg");
+        getInternalOssClient().putObject(bucketName, fullKey, inputStream, objectMetadata);
+        return fullKey;
+
+    }
+
+    /**
+     * @param duration   时长，如果是图片则传0，视频则传视频时长
+     * @param isInternal 是否内网访问
+     * @return
+     * @return String
+     * @Title: generatePresignedUrl
+     * @Description:得到对象的临时访问URL
+     * @author 王树杞
+     * @date 2019年2月25日 上午11:04:22
+     * @version 2.0
+     */
+    public static String generatePresignedUrl(String filePath, Integer duration, boolean isInternal) {
+
+        if (StringUtils.isEmpty(filePath)) {
+            return null;
+        }
+
+        if (filePath.startsWith("http")) {
+            filePath = filePath.replace(PropertiesUtils.getDownloadDomain(), "");
+            filePath = filePath.replace("https://weappupload.piaoquantv.com/", "");
+            filePath = filePath.replace("https://testweappupload.yishihui.com/", "");
+            filePath = filePath.replace("https://lvupload.piaoquantv.com/", "");
+        }
+
+        if (filePath.contains("Signature") && filePath.contains("OSSAccessKeyId")) {
+            return filePath;
+        }
+
+        if (duration == null) {
+            duration = 0;
+        }
+        // 设置URL过期时间为视频时长+3天。
+        // 单位为秒；
+        Date expiration = new Date(new Date().getTime() + (duration + (3 * 24 * 60 * 60)) * 1000);
+//		//一分钟
+//		Date expiration = new Date(new Date().getTime() +( 60) * 1000);
+        // 生成以GET方法访问的签名URL，访客可以直接通过浏览器访问相关内容。
+
+        URL url = getOssReadOnlyClient().generatePresignedUrl(PropertiesUtils.getVideoBucket(),
+                filePath, expiration, HttpMethod.GET);
+        String path = url.getFile();
+        if (StringUtils.startsWith(path, "/")) {
+            return StringUtils.substring(path, 1);
+        }
+        return path;
+
+    }
+
+    public static String saveObjectFromInternal(InputStream inputStream, String fullKey)
+            throws OSSException, ClientException, IOException {
+        String bucketName = PropertiesUtils.getVideoBucket();
+        getInternalOssClient().putObject(bucketName, fullKey, inputStream);
+        return fullKey;
+    }
+
+    public static String saveObjectFromInternal(String bucketName, String url, String fullKey)
+            throws Exception {
+        InputStream inputStream = new URL(url).openStream();
+        getInternalOssClient().putObject(bucketName, fullKey, inputStream);
+        if (inputStream != null) {
+            inputStream.close();
+        }
+        return fullKey;
+    }
+
+    public static boolean checkObjectExistFromInternal(String bucketName, String fullKey) {
+        return getInternalOssClient().doesObjectExist(bucketName, fullKey);
+    }
+
+    public static String uploadShangHaiVideo(InputStream inputStream, String key, String bucketName) {
+        ObjectMetadata objectMetadata = new ObjectMetadata();
+        objectMetadata.setContentType("video/mp4");
+        getShangHaiInternalOssClient().putObject(bucketName, key, inputStream, objectMetadata);
+        return key;
+    }
+
+    public static boolean isShangHaiExist(String bucket, String fullKey) {
+        return getShangHaiInternalOssClient().doesObjectExist(bucket, fullKey);
+    }
+
+    public static Boolean isStorageClassArchive(String bucket, String key) throws OSSException, ClientException {
+        ObjectMetadata objectMetadata = getInternalOssClient().getObjectMetadata(bucket, key);
+        StorageClass storageClass = objectMetadata.getObjectStorageClass();
+        return storageClass == StorageClass.Archive;
+    }
+
+    public static boolean isStorageClassColdArchive(String bucket, String key) throws OSSException, ClientException {
+        ObjectMetadata objectMetadata = getInternalOssClient().getObjectMetadata(bucket, key);
+        StorageClass storageClass = objectMetadata.getObjectStorageClass();
+        return storageClass == StorageClass.ColdArchive;
+    }
+
+    public static void setStorageClassToArchive(String bucket, String key) throws OSSException, ClientException {
+        // 创建CopyObjectRequest对象。
+        CopyObjectRequest request = new CopyObjectRequest(bucket, key, bucket, key);
+
+        // 创建ObjectMetadata对象。
+        ObjectMetadata objectMetadata = new ObjectMetadata();
+
+        // 封装header，此处以设置存储类型为归档类型为例。
+        objectMetadata.setHeader("x-oss-storage-class", StorageClass.Archive);
+        request.setNewObjectMetadata(objectMetadata);
+
+        // 更改文件存储类型。
+        CopyObjectResult result = getInternalOssClient().copyObject(request);
+    }
+
+    public static void recoverVideoAsync(String bucket, String srckey) {
+        OSSClient ossInternalClient = getInternalOssClient();
+        ObjectMetadata objectMetadata = ossInternalClient.getObjectMetadata(bucket, srckey);
+        // 校验文件是否为归档文件。
+        StorageClass storageClass = objectMetadata.getObjectStorageClass();
+        if (storageClass == StorageClass.Archive) {
+            // 解冻文件。
+            try {
+                ossInternalClient.restoreObject(bucket, srckey);
+            } catch (Exception e) {
+                // OSS Auto-generated catch blockvideo-common/src/main/java/com/weiqu/video/common/enums/ExceptionCodeEnum.java
+//				e.printStackTrace();
+                logger.error("视频可能在解冻中");
+            }
+        } else if (storageClass == StorageClass.ColdArchive) {
+            // 解冻文件。
+            try {
+                RestoreJobParameters parameters = new RestoreJobParameters(RestoreTier.RESTORE_TIER_EXPEDITED);
+                RestoreConfiguration configuration = new RestoreConfiguration(3, parameters);
+                ossInternalClient.restoreObject(bucket, srckey, configuration);
+            } catch (Exception ex) {
+                logger.error("视频可能在解冻中", ex);
+            }
+        }
+    }
+
+    public static Boolean isRestoreCompleted(String bucket, String key) throws OSSException, ClientException {
+        ObjectMetadata objectMetadata = getInternalOssClient().getObjectMetadata(bucket, key);
+        Boolean isRestoreCompleted = false;
+        try {
+            isRestoreCompleted = objectMetadata.isRestoreCompleted();
+        } catch (Exception e) {
+            // OSS Auto-generated catch block
+//			e.printStackTrace();
+            logger.error("视频可能在解冻中");
+        }
+
+        return isRestoreCompleted;
+    }
+
+    /**
+     * @param path
+     * @param path
+     * @return
+     * @ApiModelProperty(value="冻结状态: -1:无须解冻  0:待解冻  1:解冻中  2:解冻完成")
+     */
+    public static Integer getFrozenStatus(String path) {
+        if (path.startsWith("http") && !path.startsWith(PropertiesUtils.getDownloadDomain())) {
+            logger.info("getFrozenStatus-outer size video, path :" + path);
+            return -1;
+        }
+        String realPath = path.replace(PropertiesUtils.getDownloadDomain(), "");
+        String bucketName = PropertiesUtils.getVideoBucket();
+        ObjectMetadata objectMetadata = null;
+        try {
+            objectMetadata = getInternalOssClient().getObjectMetadata(bucketName, realPath);
+        } catch (Exception ex) {
+            logger.error("getFrozenStatus-error", ex);
+            return -1;
+        }
+
+        if (Objects.isNull(objectMetadata)) {
+            logger.error("getFrozenStatus-error, path :" + path + " do not has metaData");
+            return -1;
+        }
+        StorageClass storageClass = objectMetadata.getObjectStorageClass();
+        if (storageClass != StorageClass.Archive && storageClass != StorageClass.ColdArchive) {
+            logger.info("getFrozenStatus, path :" + path + " do not in Archive status");
+            return -1;
+        }
+        try {
+            // 解冻完成
+            boolean isRestoreCompleted = objectMetadata.isRestoreCompleted();
+            if (isRestoreCompleted) {
+                return 2;
+            } else {
+                return 1;
+            }
+        } catch (NullPointerException e) {
+            logger.info("getFrozenStatus, path :" + path + " waiting for forzed!");
+            return 0;
+        }
+    }
+
+
+    public static Map<String, Object> getMediaAllInfo(String inPath) {
+        return getMediaAllInfo(inPath, PropertiesUtils.getVideoBucket());
+    }
+
+    public static Map<String, Object> getMediaAllInfo(String inPath, String bucketName) {
+        Map<String, Object> map = new HashMap<String, Object>();
+        String encodedInput;
+        try {
+            encodedInput = URLEncoder.encode(inPath, "utf-8");
+        } catch (UnsupportedEncodingException e) {
+            logger.error("获取元数据输入流解析错误", e);
+            map.put("status", "1");
+            return map;
+        }
+        SubmitMediaInfoJobRequest request = new SubmitMediaInfoJobRequest();
+        JSONObject input = new JSONObject();
+        input.put("Bucket", bucketName);
+        input.put("Location", PropertiesUtils.getTranscodeLocation());
+        input.put("Object", encodedInput);
+        request.setInput(input.toJSONString());
+        request.setPipelineId(PropertiesUtils.getTranscodePipelineId());
+        try {
+            SubmitMediaInfoJobResponse response = new SubmitMediaInfoJobResponse();
+            response = AliOssConfig.getIAcsClient().getAcsResponse(request);
+            if (response.getMediaInfoJob().getState() != null
+                    && response.getMediaInfoJob().getState().equalsIgnoreCase("Fail")) {
+                logger.error("获取元数据错误:" + JSONObject.toJSONString(response.getMediaInfoJob())
+                        + ",requestId:" + response.getRequestId());
+                map.put("status", "2");
+                return map;
+            }
+            Properties properties = response.getMediaInfoJob().getProperties();
+            Properties.Streams.VideoStream videoStream = null;
+            if (CollectionUtils.isNotEmpty(properties.getStreams().getVideoStreamList())) {
+                videoStream = properties.getStreams().getVideoStreamList().get(0);
+            }
+            Properties.Format format = properties.getFormat();
+            logger.info("videoStream:" + JSONObject.toJSONString(videoStream));
+            logger.info("format:" + JSONObject.toJSONString(format));
+            map.put("status", "0");
+            if (properties.getWidth() != null) {
+                map.put("width", Integer.parseInt(properties.getWidth()) + "");
+            }
+            if (properties.getHeight() != null) {
+                map.put("height", Integer.parseInt(properties.getHeight()) + "");
+            }
+            if (videoStream != null) {
+                map.put("rotate", videoStream.getRotate());
+                map.put("codeName", videoStream.getCodecName());
+            }
+            if (format != null) {
+                map.put("size", format.getSize());
+                //设置成long类型的 大于0少于1的设置成1
+                if (Double.parseDouble(format.getDuration()) > 0 && Double.parseDouble(format.getDuration()) < 1) {
+                    map.put("duration", new Double(1).longValue());
+                } else {
+                    map.put("duration", StringUtils.isEmpty(format.getDuration()) ? 0 : new Double(Double.parseDouble(format.getDuration())).longValue());
+                }
+                map.put("bitRate", StringUtils.isEmpty(format.getBitrate()) ? 0 : new Double(Double.parseDouble(format.getBitrate())).longValue() * 1000);
+            }
+        } catch (ServerException e) {
+            logger.error("获取元数据服务器异常", e);
+            map.put("status", "3");
+        } catch (ClientException e) {
+            logger.error("获取元数据客户端异常", e);
+            map.put("status", "4");
+        } catch (Exception e) {
+            logger.error("获取元数据异常", e);
+            map.put("status", "5");
+        }
+        return map;
+    }
+
+    public static CopyObjectResult setStorageClassToColdArchive(String bucket, String key) {
+        CopyObjectRequest request = new CopyObjectRequest(bucket, key, bucket, key);
+        ObjectMetadata objectMetadata = new ObjectMetadata();
+
+        // 封装header，此处以设置存储类型为归档类型为例。
+        objectMetadata.setHeader("x-oss-storage-class", StorageClass.ColdArchive);
+        request.setNewObjectMetadata(objectMetadata);
+
+        // 更改文件存储类型。
+        return getInternalOssClient().copyObject(request);
+    }
+
+    public static String getRandomObjectKey(Integer fileType) {
+        String env = PropertiesUtils.getProjectEnv();
+        if (StringUtils.isEmpty(env)) {
+            env = "qa";
+        }
+        String fileName = RandomUtil.generate18String();
+        if (EnumUploadFileType.VIDEO.getIntType().equals(fileType)) {
+            fileName = "/video/" + env + "/" + DateUtils.dateToStringyyyyMMdd(new Date()) + "/" + fileName;
+        } else if (EnumUploadFileType.VOICE.getIntType().equals(fileType)) {
+            fileName = "/voice/" + env + "/" + DateUtils.dateToStringyyyyMMdd(new Date()) + "/" + fileName;
+        } else {
+            fileName = "/pic/" + env + "/" + DateUtils.dateToStringyyyyMMdd(new Date()) + "/" + fileName;
+        }
+        return getProjectName() + fileName;
+    }
+
+    public static StsTokenVO getStsToken(String fileName, Long durationSeconds) {
+
+        String endpoint = PropertiesUtils.getLongvideoStsEndpoint();
+        String accessKeyId = PropertiesUtils.getLongvideoStsAccessKeyId();
+        String accessKeySecret = PropertiesUtils.getLongvideoStsAccessKeySecret();
+        String roleArn = PropertiesUtils.getLongvideoStsRoleArn();
+        String roleSessionName = PropertiesUtils.getLongvideoStsSessionName();
+        StsTokenVO result = new StsTokenVO();
+        try {
+            String region = "cn-hangzhou";
+            DefaultProfile.addEndpoint("", "", "Sts", endpoint);
+            IClientProfile profile = DefaultProfile.getProfile("", accessKeyId, accessKeySecret);
+            DefaultAcsClient client = new DefaultAcsClient(profile);
+            final AssumeRoleRequest request = new AssumeRoleRequest();
+            request.setMethod(MethodType.POST);
+            request.setRoleArn(roleArn);
+            request.setRoleSessionName(roleSessionName);
+            //设置过期时间 临时访问凭证的有效时间，单位为秒。最小值为900，最大值以当前角色设定的最大会话时间为准。角色最大会话时间取值范围为3600秒~43200秒
+            if (Objects.nonNull(durationSeconds)) {
+                request.setDurationSeconds(durationSeconds);
+            }
+            JSONObject policy = getUploadFileStsPolicy(PropertiesUtils.getVideoBucket(), fileName);
+            request.setPolicy(policy.toJSONString());
+
+            final AssumeRoleResponse response = client.getAcsResponse(request);
+            result.setExpiration(response.getCredentials().getExpiration());
+            result.setAccessKeyId(response.getCredentials().getAccessKeyId());
+            result.setAccessKeySecret(response.getCredentials().getAccessKeySecret());
+            result.setSecurityToken(response.getCredentials().getSecurityToken());
+            result.setRequestId(response.getRequestId());
+            result.setFileName(fileName);
+            result.setHost(AliOssConfig.getUploadDomain());
+
+            String host0 = PropertiesUtils.getOssaccelerateUploadDomain();
+            String host1 = "https://" + AliOssConfig.getBucket(EnumPublicBuckets.PUBBUCKET.getBucketName()) + "." + AliOssConfig.getOssEndPoint() + "/";
+            result.setHosts(new String[]{host0, host1});
+
+            result.setBucket(PropertiesUtils.getVideoBucket());
+            result.setRegion(region);
+            result.setCname(true);
+
+            // 返回服务器当前时间
+            result.setServerTimestamp(System.currentTimeMillis());
+
+        } catch (com.aliyuncs.exceptions.ClientException e) {
+            logger.error(String.format("获取临时令牌失败,errorCode:%s;errorMessage:%s;requestId:%s",
+                    e.getErrCode(), e.getErrMsg(), e.getRequestId()));
+        } catch (Exception e) {
+            logger.error("获取临时令牌失败", e);
+        }
+        return result;
+    }
+
+    private static JSONObject getUploadFileStsPolicy(String bucketName, String fileName) {
+
+        JSONObject policy = new JSONObject();
+        policy.put("Version", "1");
+
+        JSONArray statements = new JSONArray();
+        JSONObject statement = new JSONObject();
+        statement.put("Effect", "Allow");
+
+        JSONArray action = new JSONArray();
+        action.add("oss:PutObject");
+
+        statement.put("Action", action);
+        JSONArray resource = new JSONArray();
+        resource.add("acs:oss:*:1894469520484605:" + bucketName + "/" + fileName);
+        statement.put("Resource", resource);
+
+        statements.add(statement);
+        policy.put("Statement", statements);
+
+        logger.info(String.format("Policy:%s", JSON.toJSONString(policy)));
+        return policy;
+    }
+
+    public static String downloadAndSaveInOSS(String fileName, String url, String contentType) {
+        try {
+            byte[] fileData = HttpUtil.downloadBytes(url);
+            if (fileData == null || fileData.length == 0) {
+                log.warn("下载media失败，URL: {}", url);
+                return null;
+            }
+            InputStream inputStream = new ByteArrayInputStream(fileData);
+            return CdnUtil.getOssHttpUrl(saveInPublic(EnumPublicBuckets.PUBBUCKET.getBucketName(),
+                    fileName, inputStream, contentType));
+        } catch (Exception e) {
+            log.error("下载转存OSS失败，URL: {}", url, e);
+            return null;
+        }
+    }
+}

src/main/java/com/tzld/ffmpeg/util/BaseUtils.java

@@ -0,0 +1,139 @@
+package com.tzld.ffmpeg.util;
+
+import org.apache.http.util.TextUtils;
+import org.springframework.beans.BeanUtils;
+import org.springframework.util.StringUtils;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class BaseUtils {
+
+    public static void copyProperties(Object orig, Object dest) {
+        // spring的BeanUtils性能较好
+        BeanUtils.copyProperties(orig, dest);
+    }
+
+    public static String getUUID() {
+        return UUID.randomUUID().toString();
+    }
+
+    public static String getUUIDStr() {
+        return UUID.randomUUID().toString().replaceAll("-", "");
+    }
+
+    private static String[] chars = new String[]{"a", "b", "c", "d", "e", "f",
+            "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s",
+            "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5",
+            "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I",
+            "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V",
+            "W", "X", "Y", "Z"};
+
+    public static String getShortUUIDStr() {
+        StringBuffer shortBuffer = new StringBuffer();
+        String uuid = UUID.randomUUID().toString().replace("-", "");
+        for (int i = 0; i < 8; i++) {
+            String str = uuid.substring(i * 4, i * 4 + 4);
+            int x = Integer.parseInt(str, 16);
+            shortBuffer.append(chars[x % 0x3E]);
+        }
+        return shortBuffer.toString();
+    }
+
+    public static String getShortUUIDStr_6() {
+        StringBuffer shortBuffer = new StringBuffer();
+        String uuid = UUID.randomUUID().toString().replace("-", "");
+        System.out.println("uuid = " + uuid.length() + " , chars = " + chars.length);
+        for (int i = 0; i < 6; i++) {
+            String str = uuid.substring(i * 5, i * 5 + 5);
+            int x = Integer.parseInt(str, 16);
+            shortBuffer.append(chars[x % 0x3E]);
+        }
+        return shortBuffer.toString();
+    }
+
+    /**
+     * 带时间戳的uuid
+     *
+     * @return
+     */
+    public static String getTimestampUUIDStr() {
+        return UUID.randomUUID().toString().replaceAll("-", "") + System.currentTimeMillis();
+    }
+
+    public static boolean isUidAvailable(Long uid) {
+        return Objects.nonNull(uid) && uid >= 0;
+    }
+
+    public static boolean checkEmailAddressAvailable(String email) {
+        String check = "^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\\.[a-zA-Z0-9_-]+)+$";
+        Pattern regex = Pattern.compile(check);
+        Matcher matcher = regex.matcher(email);
+        return matcher.matches();
+    }
+
+    public static int getInt(String intValue, int defaultValue) {
+        try {
+            return Integer.parseInt(intValue);
+        } catch (NumberFormatException e) {
+            e.printStackTrace();
+        }
+        return defaultValue;
+    }
+
+    public static boolean isContainChinese(String str) {
+        if (TextUtils.isEmpty(str)) {
+            return false;
+        }
+        try {
+            Pattern p = Pattern.compile("[\u4E00-\u9FA5|\\！|\\，|\\。|\\（|\\）|\\《|\\》|\\“|\\”|\\？|\\：|\\；|\\【|\\】]");
+            Matcher m = p.matcher(str);
+            if (m.find()) {
+                return true;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return false;
+    }
+
+    public static String calcRate(Integer a, Integer b) {
+        if (a == null || b == null || b == 0) {
+            return "0";
+        }
+        return new BigDecimal(a).divide(new BigDecimal(b), 2, RoundingMode.HALF_UP).toString();
+    }
+
+    public static boolean isNumberStr(String str){
+        Pattern pattern = Pattern.compile("[0-9]*");
+        return pattern.matcher(str).matches();
+    }
+
+    public static String getFirstGroupPlanExeId(String planExeId) {
+        if (StringUtils.hasText(planExeId) && planExeId.contains("_")) {
+            return planExeId.substring(0, planExeId.indexOf("_"));
+        }
+        return planExeId;
+    }
+
+    public static boolean isFirstGroupPlanExeId(String planExeId) {
+        if (StringUtils.hasText(planExeId) && planExeId.contains("_")) {
+            return false;
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(checkEmailAddressAvailable("a-a_a@q-q.A"));
+        System.out.println(getUUIDStr());
+        System.out.println(getShortUUIDStr());
+        System.out.println(getShortUUIDStr_6());
+        System.out.println(isNumberStr("20240201052729691500183"));
+        System.out.println(getFirstGroupPlanExeId("20240314125002672235936_2"));
+        System.out.println("20240314125002672235936_2".substring("20240314125002672235936_2".indexOf("_") + 1));
+    }
+}

src/main/java/com/tzld/ffmpeg/util/CdnUtil.java

@@ -0,0 +1,169 @@
+package com.tzld.ffmpeg.util;
+
+import cn.hutool.core.net.URLEncodeUtil;
+import com.alibaba.fastjson.JSON;
+import com.aliyuncs.DefaultAcsClient;
+import com.aliyuncs.IAcsClient;
+import com.aliyuncs.cdn.model.v20141111.DescribeDomainBpsDataRequest;
+import com.aliyuncs.cdn.model.v20141111.DescribeDomainBpsDataResponse;
+import com.aliyuncs.exceptions.ClientException;
+import com.aliyuncs.exceptions.ServerException;
+import com.aliyuncs.profile.DefaultProfile;
+import com.stuuudy.commons.external.filestorage.enums.EnumFileType;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Objects;
+
+public class CdnUtil {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(CdnUtil.class);
+
+//    public static final String VIDEO_CDN_URL_HOST = "https://xycdn.yishihui.com/";
+    public static final String VIDEO_CDN_URL_HOST = "http://rescdn.yishihui.com/";
+
+    public static final String PICTURE_CDN_URL_HOST_PICTURE = "http://rescdn.yishihui.com/";
+    public static final String DOWNLOAD_CDN_URL_HOST_PICTURE = "https://rescdn.yishihui.com/";
+
+
+    private static IAcsClient client;
+
+    static {
+        if (Objects.isNull(client)) {
+            DefaultProfile profile = DefaultProfile.getProfile("cn-hangzhou", "LTAInlg8tWvBeiJe", "hDu5v2nrOmdY0AjlqGnZkW57mxCOLO");
+            /** use STS Token
+             DefaultProfile profile = DefaultProfile.getProfile(
+             "<your-region-id>",           // The region ID
+             "<your-access-key-id>",       // The AccessKey ID of the RAM account
+             "<your-access-key-secret>",   // The AccessKey Secret of the RAM account
+             "<your-sts-token>");          // STS Token
+             **/
+            client = new DefaultAcsClient(profile);
+        }
+    }
+
+
+    public static Double getDescribeDomainBpsData() {
+        DescribeDomainBpsDataRequest request = new DescribeDomainBpsDataRequest();
+        //需要时区为GMT
+        LocalDateTime endTime = LocalDateTime.now().plusHours(-8);
+        LocalDateTime startTime = endTime.plusMinutes(-10);
+        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+        String[] starts = startTime.format(df).split(" ");
+        String[] ends = endTime.format(df).split(" ");
+        String start = starts[0] + "T" + starts[1] + "Z";
+        String end = ends[0] + "T" + ends[1] + "Z";
+        request.setStartTime(start);
+        request.setEndTime(end);
+        LOGGER.info("getDescribeDomainBpsData request = {}", JSON.toJSONString(request));
+        try {
+            DescribeDomainBpsDataResponse response = client.getAcsResponse(request);
+            LOGGER.info("getDescribeDomainBpsData response = {}", JSON.toJSONString(response));
+            if (Objects.isNull(response) || Objects.isNull(response.getBpsDataPerInterval())
+                    || response.getBpsDataPerInterval().isEmpty() || response.getBpsDataPerInterval().size() <= 1) {
+                //只有1条可能不准确
+                return null;
+            }
+            DescribeDomainBpsDataResponse.DataModule module1 = response.getBpsDataPerInterval().get(1);
+            if (Objects.nonNull(module1) && Objects.equals("0", module1.getValue())) {
+                return null;
+            }
+            DescribeDomainBpsDataResponse.DataModule module = response.getBpsDataPerInterval().get(0);
+            if (Objects.nonNull(module) && Objects.nonNull(module.getValue())) {
+                return Double.parseDouble(module.getValue()) / 1000 / 1000 / 1000;
+            }
+        } catch (ServerException e) {
+            LOGGER.error("getDescribeDomainBpsData ServerException", e);
+        } catch (ClientException e) {
+            LOGGER.error("getDescribeDomainBpsData ClientException", e);
+        }
+        return null;
+    }
+
+    public static String getCdnUrlHost(EnumFileType fileType) {
+        if (Objects.isNull(fileType)) {
+            return null;
+        }
+        switch (fileType) {
+            case VIDEO:
+                return VIDEO_CDN_URL_HOST;
+            case PICTURE:
+                return PICTURE_CDN_URL_HOST_PICTURE;
+        }
+        return null;
+    }
+
+
+    public static String getOssHttpUrl(String key) {
+        if (StringUtils.isBlank(key)) {
+            return key;
+        }
+        if (org.springframework.util.StringUtils.startsWithIgnoreCase(key, "http")) {
+            return key;
+        } else {
+            String url = DOWNLOAD_CDN_URL_HOST_PICTURE + key;
+            return URLEncodeUtil.encode(url);
+        }
+    }
+
+//    public static void main(String[] args_) throws Exception {
+//        DescribeDomainBpsDataRequest request = new DescribeDomainBpsDataRequest();
+//        //需要时区为GMT
+//        LocalDateTime endTime = LocalDateTime.now().plusHours(-8);
+//        LocalDateTime startTime = endTime.plusMinutes(-10);
+//        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+//        String[] starts = startTime.format(df).split(" ");
+//        String[] ends = endTime.format(df).split(" ");
+//        String start = starts[0] + "T" + starts[1] + "Z";
+//        String end = ends[0] + "T" + ends[1] + "Z";
+//        request.setStartTime(start);
+//        request.setEndTime(end);
+//        System.out.println("---" + JSON.toJSONString(request));
+//        try {
+//            DescribeDomainBpsDataResponse response = client.getAcsResponse(request);
+//
+//            System.out.println("---" + JSON.toJSONString(response));
+//            DescribeDomainBpsDataResponse.DataModule module = response.getBpsDataPerInterval().get(0);
+//
+//            System.out.println("---" + module.getValue());
+//            double d = Double.valueOf(module.getValue()) / 1000 / 1000 / 1000;
+//            System.out.println(d);
+//
+////            System.out.println(new Gson().toJson(response));
+//        } catch (ServerException e) {
+//            e.printStackTrace();
+//        } catch (ClientException e) {
+//            System.out.println("ErrCode:" + e.getErrCode());
+//            System.out.println("ErrMsg:" + e.getErrMsg());
+//            System.out.println("RequestId:" + e.getRequestId());
+//        }
+//
+//    }
+
+    public static String getFileExtensionFromUrl(String uri) {
+        if (StringUtils.isBlank(uri)) {
+            return "";
+        }
+        String fileExtension = "";
+        try {
+            if (uri.contains(".")) {
+                int lastDotIndex = uri.lastIndexOf('.');
+                if (lastDotIndex > 0) {
+                    fileExtension = uri.substring(lastDotIndex + 1);
+                }
+            }
+        } catch (Exception e) {
+            LOGGER.error("getFileExtensionFromURL error", e);
+        }
+        return fileExtension;
+    }
+
+    public static void main(String[] args) {
+        String url = "ad/material_1564536000000.mp4";
+        System.out.println(getFileExtensionFromUrl(url));
+    }
+
+}

src/main/java/com/tzld/ffmpeg/util/DateUtils.java

@@ -0,0 +1,333 @@
+package com.tzld.ffmpeg.util;
+
+import org.springframework.util.StringUtils;
+
+import java.text.SimpleDateFormat;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+import java.time.temporal.ChronoUnit;
+import java.util.*;
+
+/**
+ * @author dyp
+ */
+public final class DateUtils {
+    public static String getCurrentDateStr(String format) {
+        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
+        Date currentDate = new Date();
+        return dateFormat.format(currentDate);
+    }
+
+    public static int getCurrentHour() {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
+        return calendar.get(Calendar.HOUR_OF_DAY);
+    }
+
+    public static String getBeforeDaysDateStr(String format, int d) {
+        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
+        calendar.setTime(new Date());
+        calendar.add(Calendar.DAY_OF_MONTH, -d);
+        Date previousDate = calendar.getTime();
+        return dateFormat.format(previousDate);
+    }
+
+    public static String getBeforeDaysDateStr(String dateStr, String format, int d) {
+        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
+        Date date = new Date();
+        try {
+            date = dateFormat.parse(dateStr);
+        } catch (Exception ignore) {}
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
+        calendar.setTime(date);
+        calendar.add(Calendar.DAY_OF_MONTH, -d);
+        Date previousDate = calendar.getTime();
+        return dateFormat.format(previousDate);
+    }
+
+
+    public static boolean ifTimeRangeInNow(String timeRange) {
+        try {
+
+            String[] split = timeRange.split("-");
+            if (split.length != 2) {
+                return false;
+            }
+            String startTime = split[0];
+            String endTime = split[1];
+            if (startTime.length() != 10 || endTime.length() != 10) {
+                return false;
+            }
+            LocalDateTime now = LocalDateTime.now();
+            LocalDateTime start = LocalDateTime.parse(startTime, DateTimeFormatter.ofPattern("yyyyMMddHH"));
+            LocalDateTime end = LocalDateTime.parse(endTime, DateTimeFormatter.ofPattern("yyyyMMddHH"));
+            return now.equals(start) || (now.isAfter(start) && now.isBefore(end));
+        } catch (Exception e) {
+//            e.printStackTrace();
+            return false;
+        }
+    }
+
+    public static long dateStrToTimestamp(String dateStr, String format) {
+        // 定义日期格式
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);
+
+        // 解析输入的日期字符串为LocalDate对象
+        LocalDate date = LocalDate.parse(dateStr, formatter);
+
+        // 将LocalDate转换为LocalDateTime，时间部分设为00:00:00
+        LocalDateTime dateTime = date.atStartOfDay();
+
+        // 定义北京时区
+        ZoneId zone = ZoneId.of("Asia/Shanghai");
+
+        // 将LocalDateTime转换为时间戳（秒数），使用北京时区
+        return dateTime.toEpochSecond(zone.getRules().getOffset(dateTime));
+    }
+
+    public static boolean isValidDate(String dateString) {
+        // 定义日期格式
+        DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+
+        try {
+            // 尝试解析日期字符串
+            LocalDate date = LocalDate.parse(dateString, dateFormatter);
+            return true; // 如果解析成功，返回 true
+        } catch (DateTimeParseException e) {
+            return false; // 如果解析失败，返回 false
+        }
+    }
+
+    public static String timestampToYMDStr(Long timestamp, String format) {
+
+        // 定义北京时区
+        ZoneId zone = ZoneId.of("Asia/Shanghai");
+
+        // 将时间戳转换为LocalDateTime
+        LocalDateTime dateTime = LocalDateTime.ofInstant(Instant.ofEpochSecond(timestamp), zone);
+
+        // 定义日期格式为"yyyyMMddHHmmss"
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);
+
+        // 将LocalDateTime格式化为字符串
+        return dateTime.format(formatter);
+    }
+
+    public static String findNearestDate(List<String> dateList, String targetDateStr, String format) {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);
+        // 将目标日期字符串转换为 LocalDate
+        LocalDate targetDate = LocalDate.parse(targetDateStr, formatter);
+
+        // 初始化最近的日期和最小的天数差值
+        String nearestDateStr = null;
+        long minDiff = Long.MAX_VALUE;
+
+        // 遍历日期列表，找到最近的日期
+        for (String dateStr : dateList) {
+            LocalDate currentDate = LocalDate.parse(dateStr, formatter);
+            long diff = Math.abs(ChronoUnit.DAYS.between(currentDate, targetDate));  // 计算天数差异
+
+            // 如果找到更小的差异，更新最近的日期
+            if (diff < minDiff) {
+                minDiff = diff;
+                nearestDateStr = dateStr;
+            }
+        }
+
+        return nearestDateStr;  // 返回最近的日期字符串
+    }
+
+    public static List<String> getBeforeDays(String beginDate, String endDate, int days) {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
+        // 获取今天的日期
+        LocalDate today = LocalDate.now();
+        if (!StringUtils.hasText(beginDate)) {
+            beginDate = today.format(formatter);
+        }
+        if (!StringUtils.hasText(endDate)) {
+            endDate = today.format(formatter);
+        }
+        // 解析输入的日期字符串为LocalDate对象
+        LocalDate date = LocalDate.parse(beginDate, formatter);
+        LocalDate end = LocalDate.parse(endDate, formatter);
+        // 获取从输入日期前三天的日期
+        LocalDate startDate = date.minusDays(days);
+        // 存储所有日期的列表
+        List<String> datesList = new ArrayList<>();
+        // 从startDate到today遍历日期
+        while (startDate.isBefore(today) && !startDate.isAfter(end)) {
+            // 将当前日期格式化为"yyyyMMdd"并添加到列表中
+            datesList.add(startDate.format(formatter));
+            // 日期加1天
+            startDate = startDate.plusDays(1);
+        }
+        return datesList;
+    }
+
+    // 获取每日最小秒数 (当天零点)
+    public static Long getStartOfDay(String dateStr, String formatter) {
+        try {
+            SimpleDateFormat sdf = new SimpleDateFormat(formatter);
+            Date date = sdf.parse(dateStr);
+
+            Calendar calendar = Calendar.getInstance();
+            calendar.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
+            calendar.setTime(date);
+            calendar.set(Calendar.HOUR_OF_DAY, 0);
+            calendar.set(Calendar.MINUTE, 0);
+            calendar.set(Calendar.SECOND, 0);
+            calendar.set(Calendar.MILLISECOND, 0);
+
+            return calendar.getTimeInMillis();
+        } catch (Exception e) {
+            Date date = new Date();
+            return date.getTime();
+        }
+    }
+
+    public static Date getStartDateOfDay(Long timestamp) {
+        try {
+            Calendar calendar = Calendar.getInstance();
+            // 设置时区为UTC（你可以根据需要更改时区）
+            calendar.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
+            // 将时间戳转换为毫秒并设置时间
+            calendar.setTimeInMillis(timestamp);
+            calendar.set(Calendar.HOUR_OF_DAY, 0);
+            calendar.set(Calendar.MINUTE, 0);
+            calendar.set(Calendar.SECOND, 0);
+            calendar.set(Calendar.MILLISECOND, 0);
+
+            return calendar.getTime();
+        } catch (Exception e) {
+            return new Date();
+        }
+    }
+
+    // 获取每日最大秒数 (当天的23:59:59)
+    public static Long getEndOfDay(String dateStr, String formatter) {
+        try {
+            SimpleDateFormat sdf = new SimpleDateFormat(formatter);
+            Date date = sdf.parse(dateStr);
+
+            Calendar calendar = Calendar.getInstance();
+            calendar.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
+            calendar.setTime(date);
+            calendar.set(Calendar.HOUR_OF_DAY, 23);
+            calendar.set(Calendar.MINUTE, 59);
+            calendar.set(Calendar.SECOND, 59);
+            calendar.set(Calendar.MILLISECOND, 999);
+
+            return calendar.getTimeInMillis();
+        } catch (Exception e) {
+            Date date = new Date();
+            return date.getTime();
+        }
+    }
+
+    public static Integer getHourByTimestamp(Long timestamp) {
+        Calendar calendar = Calendar.getInstance();
+        // 设置时区为UTC（你可以根据需要更改时区）
+        calendar.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
+        // 将时间戳转换为毫秒并设置时间
+        calendar.setTimeInMillis(timestamp);
+        // 获取小时
+        return calendar.get(Calendar.HOUR_OF_DAY);
+    }
+
+    public static int getMinuteByTimestamp(long timestamp) {
+        Calendar calendar = Calendar.getInstance();
+        // 设置时区为UTC（你可以根据需要更改时区）
+        calendar.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
+        // 将时间戳转换为毫秒并设置时间
+        calendar.setTimeInMillis(timestamp);
+        // 获取小时
+        return calendar.get(Calendar.MINUTE);
+    }
+
+
+    public static void main(String[] args) {
+        Calendar calendar = Calendar.getInstance();
+
+        System.out.println((calendar.get(Calendar.DAY_OF_WEEK) + 6) % 7);
+        System.out.println(new SimpleDateFormat("yyyyMMdd").format(calendar.getTime()));
+        System.out.println(new SimpleDateFormat("HH").format(calendar.getTime()));
+
+    }
+
+    public static Long getTodayStart() {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
+        calendar.set(Calendar.HOUR_OF_DAY, 0);
+        calendar.set(Calendar.MINUTE, 0);
+        calendar.set(Calendar.SECOND, 0);
+        calendar.set(Calendar.MILLISECOND, 0);
+        return calendar.getTime().getTime();
+    }
+
+    public static Long getBeforeDayStart(int days) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
+        calendar.set(Calendar.HOUR_OF_DAY, 0);
+        calendar.set(Calendar.MINUTE, 0);
+        calendar.set(Calendar.SECOND, 0);
+        calendar.set(Calendar.MILLISECOND, 0);
+        calendar.add(Calendar.DAY_OF_MONTH, -days);
+        return calendar.getTime().getTime();
+    }
+
+    public static String getBeforeDayStr(String dateStr, String format, int days) {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);
+        LocalDate date = LocalDate.parse(dateStr, formatter);
+        date = date.minusDays(days);
+        return date.format(formatter);
+    }
+
+    public static String getDateString(Long timestamp) {
+        // 创建日期时间格式化器
+        DateTimeFormatter dateFormat = DateTimeFormatter.ofPattern("yyyyMMdd");
+        // 将时间戳转换为 LocalDateTime
+        ZoneId zone = ZoneId.of("Asia/Shanghai");
+        LocalDateTime dateTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), zone);
+        // 格式化日期时间并返回
+        return dateTime.format(dateFormat);
+    }
+
+    public static String getDateString(Long timestamp, String pattern) {
+        // 创建日期时间格式化器
+        DateTimeFormatter dateFormat = DateTimeFormatter.ofPattern(pattern);
+        // 将时间戳转换为 LocalDateTime
+        ZoneId zone = ZoneId.of("Asia/Shanghai");
+        LocalDateTime dateTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), zone);
+        // 格式化日期时间并返回
+        return dateTime.format(dateFormat);
+    }
+
+    public static Date getDate(String dateString) {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+        LocalDate localDate = LocalDate.parse(dateString, formatter);
+        ZoneId zone = ZoneId.of("Asia/Shanghai");
+        return Date.from(localDate.atStartOfDay(zone).toInstant());
+    }
+
+    /**
+     * 日期型转化成字符串类型
+     * @param date
+     * @return
+     */
+    public static String dateToStringyyyyMMdd(Date date) {
+        return new SimpleDateFormat("yyyyMMdd").format(date);
+    }
+
+    public static String formatIso8601Date(Date date) {
+        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
+        df.setTimeZone(new SimpleTimeZone(8, "GMT"));
+        return df.format(date);
+    }
+}

src/main/java/com/tzld/ffmpeg/util/DistributedIdGenerator.java

@@ -0,0 +1,23 @@
+package com.tzld.ffmpeg.util;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Random;
+
+public abstract class DistributedIdGenerator {
+    /**
+     * 生成一个
+     *
+     * @return
+     */
+    public static String generate() {
+        StringBuilder builder = new StringBuilder();
+        builder.append(new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date()));
+        builder.append(new Random().nextInt(899999) + 100000);
+        return builder.toString();
+    }
+
+    public static void main(String[] args) {
+        System.out.println(generate());
+    }
+}

src/main/java/com/tzld/ffmpeg/util/FFmpegUtil.java

@@ -0,0 +1,1668 @@
+package com.tzld.ffmpeg.util;
+
+import cn.hutool.core.collection.CollectionUtil;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.tzld.ffmpeg.exception.FFmpegExecuteException;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.io.IOUtils;
+import org.springframework.util.StringUtils;
+
+import java.io.File;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+@Slf4j
+public class FFmpegUtil {
+
+    /**
+     * 获取媒体信息（宽、高、时长）
+     *
+     * @param mediaUrl 媒体url，可以是网络url或者文件路径
+     * @return
+     */
+    public static MediaInfo getMediaInfo(String mediaUrl) {
+        MediaInfo mediaInfo = new MediaInfo();
+        // ffprobe -v quiet -print_format json -show_format -show_streams -i 1.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffprobe");
+        commands.add("-v");
+        commands.add("quiet");
+        commands.add("-print_format");
+        commands.add("json");
+        commands.add("-show_format");
+        commands.add("-show_streams");
+        commands.add("-i");
+        commands.add(mediaUrl);
+
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("getMediaInfo,ffmpeg执行失败");
+        }
+        if (ffmpegResult.isSuccessful()) {
+            JSONObject jsonObject = JSON.parseObject(ffmpegResult.getResultContent());
+            JSONObject formatJson = jsonObject.getJSONObject("format");
+            if (Objects.nonNull(formatJson)) {
+                String durationStr = formatJson.getString("duration");
+                if (StringUtils.hasText(durationStr)) {
+                    String[] split = durationStr.split("\\.");
+                    mediaInfo.setDuration(Integer.valueOf(split[0]) * 1000 + Integer.valueOf(split[1]) / 1000);
+                }
+                String sizeStr = formatJson.getString("size");
+                if (StringUtils.hasText(sizeStr)) {
+                    mediaInfo.setSize(Integer.valueOf(sizeStr));
+                }
+            }
+            JSONArray streams = jsonObject.getJSONArray("streams");
+            if (CollectionUtil.isNotEmpty(streams)) {
+                for (Object stream : streams) {
+                    JSONObject streamJson = (JSONObject) stream;
+                    if ("video".equals(streamJson.getString("codec_type"))) {
+                        mediaInfo.setWidth(streamJson.getInteger("width"));
+                        mediaInfo.setHeight(streamJson.getInteger("height"));
+                        mediaInfo.setAvgFrameRate(FFmpegUtil.parseAndCalcAvgFrameRate(streamJson.getString("avg_frame_rate")));
+                        mediaInfo.setTimeBase(FFmpegUtil.parseAndCalcTimeBase(streamJson.getString("time_base")));
+                    } else if ("audio".equals(streamJson.getString("codec_type"))) {
+                        mediaInfo.setSampleRate(streamJson.getInteger("sample_rate"));
+                    }
+                }
+            }
+        }
+        return mediaInfo;
+    }
+
+    /**
+     * 截取视频片段
+     *
+     * @param inputVideo
+     * @param startTime
+     * @param cutTime
+     * @param outputFilePath
+     * @return
+     */
+    public static void cutVideo(String inputVideo, String startTime, String cutTime, String outputFilePath) {
+        // ffmpeg -ss 00:00:00.000 -i 1.mp4 -t 5.100 -c:v copy -c:a copy -y output.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-ss");
+        commands.add(startTime);
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-t");
+        commands.add(cutTime);
+        commands.add("-c:v");
+        commands.add("copy");
+        commands.add("-c:a");
+        commands.add("copy");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("cutVideo,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 截取视频片段，根据时间范围
+     */
+    public static void cutVideoTime(String inputVideo, String startTime, String endTime, String outputFilePath) {
+        // ffmpeg -ss 00:00:00.000 -i 1.mp4 -t 5.100 -c:v copy -c:a copy -y output.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-ss");
+        commands.add(startTime);
+        commands.add("-to");
+        commands.add(endTime);
+        commands.add("-c:v");
+        commands.add("copy");
+        commands.add("-c:a");
+        commands.add("copy");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("cutVideo,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 精确截取视频片段（需重新编码，速度慢）
+     *
+     * @param inputVideo
+     * @param startTime
+     * @param cutTime
+     * @param outputFilePath
+     * @return
+     */
+    public static void accurateCutVideo(String inputVideo, String startTime, String cutTime, String outputFilePath) {
+        // ffmpeg -ss 00:00:00.000 -i 1.mp4 -t 5.100 -y output.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-ss");
+        commands.add(startTime);
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-t");
+        commands.add(cutTime);
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("cutVideo,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 截取音频片段
+     *
+     * @param inputAudio
+     * @param startTime
+     * @param cutTime
+     * @param outputFilePath
+     * @return
+     */
+    public static void cutAudio(String inputAudio, String startTime, String cutTime, String outputFilePath) {
+        // ffmpeg -ss 00:00:00.000 -i 1.mp3 -t 5.100 -c copy -y output.mp3
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-ss");
+        commands.add(startTime);
+        commands.add("-i");
+        commands.add(inputAudio);
+        commands.add("-t");
+        commands.add(cutTime);
+        commands.add("-c");
+        commands.add("copy");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("cutAudio,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 音频切分
+     *
+     * @param inputAudio
+     * @param segmentTime
+     * @param outputFilePath
+     */
+    public static void audioSplit(String inputAudio, int segmentTime, String outputFilePath) {
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputAudio);
+        commands.add("-f");
+        commands.add("segment");
+        commands.add("-segment_time");
+        commands.add(String.valueOf(segmentTime));
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("audioSplit,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 精确截取音频片段（需重新编码，速度慢）
+     *
+     * @param inputAudio
+     * @param startTime
+     * @param cutTime
+     * @param outputFilePath
+     * @return
+     */
+    public static void accurateCutAudio(String inputAudio, String startTime, String cutTime, String outputFilePath) {
+        // ffmpeg -ss 00:00:00.000 -i 1.mp3 -t 5.100 -c copy -y output.mp3
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-ss");
+        commands.add(startTime);
+        commands.add("-i");
+        commands.add(inputAudio);
+        commands.add("-t");
+        commands.add(cutTime);
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("cutAudio,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 视频倍数
+     *
+     * @param inputVideo
+     * @param multiple       倍数，取值范围 [0.01 - 100]，小于1表示放慢，大于1表示加速，仅支持两位小数
+     * @param outputFilePath
+     * @return
+     */
+    public static void multipleVideo(String inputVideo, double multiple, String outputFilePath) {
+        // 4倍数
+        // ffmpeg -i 1.mp4 -filter_complex "[0:v]setpts=1/4*PTS[v];[0:a]atempo=4[a]" -map "[v]" -map "[a]" -y
+        // output4.mp4
+        // 0.25倍数
+        // ffmpeg -i output4.mp4 -filter_complex "[0:v]setpts=4*PTS[v];[0:a]atempo=1/2,atempo=1/2[a]" -map "[v]" -map
+        // "[a]" -y output5.mp4
+        // atempo [0.5, 100.0] range
+        // 仅视频轨道倍数 ffmpeg -i test.mp4 -filter:v "setpts=0.5*PTS" test-0.5.mp4
+        String multipleParams = "";
+//        if (multiple >= 1) {
+//            multipleParams = "[0:v]setpts=1/" + multiple + "*PTS[v];[0:a]atempo=" + multiple + "[a]";
+//        } else {
+//            StringBuilder sb = new StringBuilder();
+//            String atempoParams = buildMultipleAtempoParams(sb, multiple);
+//            multipleParams = "[0:v]setpts=1/" + multiple + "*PTS[v];[0:a]" + atempoParams + "[a]";
+//        }
+        multipleParams = "setpts=1/" + multiple + "*PTS";
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputVideo);
+//        commands.add("-filter_complex");
+        commands.add("-filter:v");
+        commands.add(multipleParams);
+//        commands.add("-map");
+//        commands.add("[v]");
+//        commands.add("-map");
+//        commands.add("[a]");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("multipleVideo,ffmpeg执行失败");
+        }
+    }
+
+    private static String buildMultipleAtempoParams(StringBuilder sb, double multiple) {
+        double minLimit = 0.5;
+        if (multiple >= minLimit) {
+            return "atempo=" + multiple;
+        } else {
+            sb.append("atempo=").append(minLimit);
+            sb.append(",");
+            BigDecimal a = new BigDecimal(multiple);
+            BigDecimal b = new BigDecimal(minLimit);
+            double newMultiple = a.divide(b, 2, RoundingMode.HALF_UP).doubleValue();
+            if (newMultiple >= minLimit) {
+                sb.append("atempo=").append(newMultiple);
+                return sb.toString();
+            } else {
+                return buildMultipleAtempoParams(sb, newMultiple);
+            }
+        }
+    }
+
+    /**
+     * 视频倒放
+     *
+     * @param inputVideo
+     * @param outputFilePath
+     * @return
+     */
+    public static void reverseVideo(String inputVideo, String outputFilePath) {
+        // ffmpeg -i input.mp4 -vf reverse reversed.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-vf");
+        commands.add("reverse");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("reverseVideo,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 视频循环
+     *
+     * @param inputVideo
+     * @param loop
+     * @param outputFilePath
+     * @return
+     */
+    public static void loopVideo(String inputVideo, int loop, String outputFilePath) {
+        // ffmpeg -stream_loop 2 -i 7.mp4 -c copy out5.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-stream_loop");
+        commands.add(loop + "");
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-c");
+        commands.add("copy");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("loopVideo,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 多个视频拼接
+     *
+     * @param concatVideosFilePath
+     * @param outputFilePath
+     * @return
+     */
+    public static void concatVideos(String concatVideosFilePath, String outputFilePath) {
+        // ffmpeg -f concat -safe 0 -i filelist.txt -c copy output1.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-f");
+        commands.add("concat");
+        commands.add("-safe");
+        commands.add("0");
+        commands.add("-i");
+        commands.add(concatVideosFilePath);
+        commands.add("-c");
+        commands.add("copy");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("concatVideos,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 多个视频拼接并重新编码
+     *
+     * @param concatVideosFilePath
+     * @param outputFilePath
+     * @return
+     */
+    public static void concatVideosAndTranscode(String concatVideosFilePath, String outputFilePath) {
+        // ffmpeg -f concat -safe 0 -i filelist.txt -c copy output1.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-f");
+        commands.add("concat");
+        commands.add("-safe");
+        commands.add("0");
+        commands.add("-i");
+        commands.add(concatVideosFilePath);
+        commands.add("-c:v");
+        commands.add("libx264");
+        commands.add("-c:a");
+        commands.add("aac");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("concatVideosAndTranscode,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 多个音频拼接
+     *
+     * @param concatAudiosFilePath
+     * @param outputFilePath
+     * @return
+     */
+    public static void concatAudios(String concatAudiosFilePath, String outputFilePath) {
+        // ffmpeg -f concat -safe 0 -i filelist.txt -codec libmp3lame output1.mp3
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-f");
+        commands.add("concat");
+        commands.add("-safe");
+        commands.add("0");
+        commands.add("-i");
+        commands.add(concatAudiosFilePath);
+        commands.add("-codec");
+        commands.add("libmp3lame");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("concatAudios,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 添加音频
+     *
+     * @param inputVideo
+     * @param inputAudio
+     * @param outputFilePath
+     * @return
+     */
+    public static void addAudio(String inputVideo, String inputAudio, String outputFilePath) {
+        // ffmpeg -i output.mp4 -i 1.mp3 -c copy -map 0:v:0 -map 1:a:0 -y output2.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-i");
+        commands.add(inputAudio);
+        commands.add("-c");
+        commands.add("copy");
+        commands.add("-map");
+        commands.add("0:v:0");
+        commands.add("-map");
+        commands.add("1:a:0");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("addAudio,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 添加音频，以短时长为准
+     */
+    public static void addAudioSelfAdaption(String inputVideo, String inputAudio, String outputFilePath) {
+        // ffmpeg -i output.mp4 -i 1.mp3 -c copy -map 0:v:0 -map 1:a:0 -y output2.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-i");
+        commands.add(inputAudio);
+        commands.add("-c");
+        commands.add("copy");
+        commands.add("-map");
+        commands.add("0:v:0");
+        commands.add("-map");
+        commands.add("1:a:0");
+        commands.add("-shortest");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("addAudioSelfAdaption,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 添加音频，循环视频并且以短时长为准
+     */
+    public static void addAudioLoopVideoAndShortest(String inputVideo, String inputAudio, String outputFilePath,
+                                                    int loopCount) {
+        // ffmpeg -i output.mp4 -i 1.mp3 -c copy -map 0:v:0 -map 1:a:0 -y output2.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-stream_loop");
+        commands.add(loopCount + "");
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-i");
+        commands.add(inputAudio);
+        commands.add("-c");
+        commands.add("copy");
+        commands.add("-map");
+        commands.add("0:v:0");
+        commands.add("-map");
+        commands.add("1:a:0");
+        commands.add("-shortest");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("addAudioLoopVideoAndShortest,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 添加音频，循环音频并且以短时长为准
+     */
+    public static void addAudioLoopAudioAndShortest(String inputVideo, String inputAudio, String outputFilePath,
+                                                    int loopCount) {
+        // ffmpeg -i output.mp4 -i 1.mp3 -c copy -map 0:v:0 -map 1:a:0 -y output2.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-stream_loop");
+        commands.add(loopCount + "");
+        commands.add("-i");
+        commands.add(inputAudio);
+        commands.add("-c");
+        commands.add("copy");
+        commands.add("-map");
+        commands.add("0:v:0");
+        commands.add("-map");
+        commands.add("1:a:0");
+        commands.add("-shortest");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("addAudioLoopVideoAndShortest,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 视频混合音频（保留视频原声）
+     *
+     * @param inputVideo
+     * @param inputAudio
+     * @param outputFilePath
+     * @return
+     */
+    public static void videoAmixAudio(String inputVideo, String inputAudio, String outputFilePath) {
+        // ffmpeg -i 7.mp4 -i 3.mp3 -filter_complex "[0:a] [1:a] amix=inputs=2:duration=first [aout]" -map 0:v -map "[aout]" -y output.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-i");
+        commands.add(inputAudio);
+        commands.add("-filter_complex");
+        commands.add("[0:a] [1:a] amix=inputs=2:duration=first [aout]");
+        commands.add("-map");
+        commands.add("0:v");
+        commands.add("-map");
+        commands.add("[aout]");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("videoAmixAudio,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 视频混合音频（保留视频原声），循环视频并且以短时长为准
+     *
+     * @param inputVideo
+     * @param inputAudio
+     * @param outputFilePath
+     * @return
+     */
+    public static void videoAmixAudioLoopVideoAndShortest(String inputVideo, String inputAudio, String outputFilePath, int loopCount) {
+        // ffmpeg -stream_loop 1 -i 7.mp4 -i 3.mp3 -filter_complex "[0:a] [1:a] amix=inputs=2:duration=shortest [aout]" -map 0:v -map "[aout]" -y output.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-stream_loop");
+        commands.add(loopCount + "");
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-i");
+        commands.add(inputAudio);
+        commands.add("-filter_complex");
+        commands.add("[0:a] [1:a] amix=inputs=2:duration=shortest [aout]");
+        commands.add("-map");
+        commands.add("0:v");
+        commands.add("-map");
+        commands.add("[aout]");
+        commands.add("-shortest");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("videoAmixAudioLoopVideoAndShortest,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 视频混合音频（保留视频原声），循环音频并且以短时长为准
+     *
+     * @param inputVideo
+     * @param inputAudio
+     * @param outputFilePath
+     * @return
+     */
+    public static void videoAmixAudioLoopAudioAndShortest(String inputVideo, String inputAudio, String outputFilePath, int loopCount) {
+        // ffmpeg -stream_loop 1 -i 7.mp4 -i 3.mp3 -filter_complex "[0:a] [1:a] amix=inputs=2:duration=shortest [aout]" -map 0:v -map "[aout]" -y output.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-stream_loop");
+        commands.add(loopCount + "");
+        commands.add("-i");
+        commands.add(inputAudio);
+        commands.add("-filter_complex");
+        commands.add("[0:a] [1:a] amix=inputs=2:duration=shortest [aout]");
+        commands.add("-map");
+        commands.add("0:v");
+        commands.add("-map");
+        commands.add("[aout]");
+        commands.add("-shortest");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("videoAmixAudioLoopAudioAndShortest,ffmpeg执行失败");
+        }
+    }
+
+    public static void delogo(String inputImage, String outputImage, String delogoPosition) {
+        // ffmpeg -i 1.jpeg -vf delogo=x=50:y=1100:w=120:h=120:show=0 dologo1.jpeg
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputImage);
+        commands.add("-vf");
+        commands.add("delogo=" + delogoPosition + ":show=0");
+        commands.add(outputImage);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("delogo,ffmpeg执行失败:" + ffmpegResult.getResultContent());
+        }
+    }
+
+    /**
+     * 添加字幕
+     *
+     * @param inputVideo
+     * @param inputSubtitleAndStyle
+     * @param outputFilePath
+     * @return
+     */
+    public static void addSubtitle(String inputVideo, String inputSubtitleAndStyle, String outputFilePath) {
+        // ffmpeg -i 1.mp4 -vf subtitles=1.srt:force_style='Fontname=DejaVu Serif,PrimaryColour=&HCCFF0000' -y
+        // output6.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-vf");
+        commands.add(inputSubtitleAndStyle);
+        commands.add("-preset");
+        commands.add("superfast");
+        commands.add("-c:a");
+        commands.add("copy");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("addSubtitle,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 剪辑视频（设置宽高、填充黑边、裁剪）
+     *
+     * @param inputVideo
+     * @param clipParams
+     * @param outputFilePath
+     * @return
+     */
+    public static void clipVideo(String inputVideo, String clipParams, String outputFilePath) {
+        // 视频压缩填充黑边
+        // ffmpeg -i 2.mp4 -vf 'scale=900:900,pad=900:1600:0:350:black' -y output7.mp4
+        // 视频放大裁剪
+        // ffmpeg -i 4.mp4 -vf 'scale=1080:-1,crop=1080:1080:0:420' -y output10.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-vf");
+        commands.add(clipParams);
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("clipVideo,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 剪辑并重新编码视频（设置宽高、填充黑边、裁剪）
+     *
+     * @param inputVideo
+     * @param clipParams
+     * @param outputFilePath
+     * @return
+     */
+    public static void clipAndTranscodeVideo(String inputVideo, String clipParams, String outputFilePath, Integer avgFrameRate, Integer timeBase) {
+        // ffmpeg -i input.mp4 -c:v libx264 -preset slow -crf 23 -c:a aac -b:a 128k -ar 44100 -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2" output.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-c:v");
+        commands.add("libx264");
+        commands.add("-preset");
+        commands.add("superfast");
+        commands.add("-crf");
+        commands.add("28");
+        commands.add("-c:a");
+        commands.add("aac");
+        commands.add("-b:a");
+        commands.add("128k");
+        commands.add("-ar");
+        commands.add("44100");
+        if (Objects.nonNull(avgFrameRate)) {
+            commands.add("-r");
+            commands.add(avgFrameRate.toString());
+        }
+        if (Objects.nonNull(timeBase)) {
+            commands.add("-video_track_timescale");
+            commands.add(timeBase.toString());
+        }
+
+        commands.add("-vf");
+        commands.add(clipParams);
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("clipAndTranscodeVideo,ffmpeg执行失败");
+        }
+    }
+
+    public static void generateBlackVideo(int width, int height, String duration, String outputFilePath) {
+        // ffmpeg -f lavfi -i color=size=1920x1080:rate=25:color=black:duration=5 -y black.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-f");
+        commands.add("lavfi");
+        commands.add("-i");
+        String params = "color=size=" + width + "x" + height + ":rate=25:color=black:duration=" + duration;
+        commands.add(params);
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("generateBlackVideo,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 视频指定时间截图
+     *
+     * @param mediaUrl 媒体url，可以是网络url或者文件路径
+     * @return
+     */
+    public static String getTimeImage(String mediaUrl, String time, String outputFilePath, int retryTimes) {
+        // ffmpeg -ss 00:50:00 -i RevolutionOS.rmvb -frames:v 1 outPut.jpg
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(mediaUrl);
+        commands.add("-ss");
+        commands.add(time);
+        commands.add("-frames:v");
+        commands.add("1");
+        commands.add("-y");
+        commands.add(outputFilePath);
+
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (ffmpegResult.isSuccessful()) {
+            return outputFilePath;
+        } else {
+            if (retryTimes > 10) {
+                return null;
+            }
+            retryTimes++;
+            return getTimeImage(mediaUrl, time, outputFilePath, retryTimes);
+        }
+    }
+
+    /**
+     * 获取视频音频
+     *
+     * @param mediaUrl 媒体url，可以是网络url或者文件路径
+     * @return
+     */
+    public static String getVideoVoice(String mediaUrl, String outputFilePath) {
+        // ffmpeg -i inputVideo.mp4 -vn -ar 44100 -ac 2 -b:a 192k output.mp3
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(mediaUrl);
+        commands.add("-vn");
+        commands.add("-ar");
+        commands.add("44100");
+        commands.add("-ac");
+        commands.add("2");
+        commands.add("-b:a");
+        commands.add("192k");
+        commands.add(outputFilePath);
+
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (ffmpegResult.isSuccessful()) {
+            return outputFilePath;
+        }
+        return null;
+    }
+
+    /**
+     * 获取视频音频
+     *
+     * @param mediaUrl 媒体url，可以是网络url或者文件路径
+     * @return
+     */
+    public static String getVideoVoice(String mediaUrl, String startTime, String endTime, String outputFilePath) {
+        // ffmpeg -i inputVideo.mp4 -vn -ar 44100 -ac 2 -b:a 192k output.mp3
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(mediaUrl);
+        commands.add("-ss");
+        commands.add(startTime);
+        commands.add("-to");
+        commands.add(endTime);
+        commands.add("-vn");
+        commands.add("-ar");
+        commands.add("44100");
+        commands.add("-ac");
+        commands.add("2");
+        commands.add("-b:a");
+        commands.add("192k");
+        commands.add(outputFilePath);
+
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (ffmpegResult.isSuccessful()) {
+            return outputFilePath;
+        }
+        return null;
+    }
+
+    /**
+     * 去除背景并合并视频
+     *
+     * @param mainVideo
+     * @param bgVideo
+     * @param color
+     * @param outputFilePath
+     * @return
+     */
+    public static void removeColorAndMergeBgVideo(String mainVideo, String bgVideo, String color, String outputFilePath) {
+        // ffmpeg -i 6.mp4 -i green.mp4 -filter_complex "[1:v]chromakey=0x00FF00:0.2:0.1[ckout];[0:v][ckout]overlay[out]" -map 0:a -map "[out]" -y out3.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(bgVideo);
+        commands.add("-i");
+        commands.add(mainVideo);
+        commands.add("-filter_complex");
+        String param = "[1:v]chromakey={color}:0.2:0.1[ckout];[0:v][ckout]overlay[out]";
+        param = param.replace("{color}", color);
+        commands.add(param);
+        commands.add("-map");
+        commands.add("0:a");
+        commands.add("-map");
+        commands.add("[out]");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("removeColorAndMergeBgVideo,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 合并背景视频
+     *
+     * @param mainVideo
+     * @param bgVideo
+     * @param outputFilePath
+     */
+    public static void mergeBgVideo(String mainVideo, String bgVideo, String outputFilePath) {
+        // ffmpeg -i 7.mp4 -i out1.mov -filter_complex "[0:v][1:v]overlay=0:0" -c:a copy out5.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(mainVideo);
+        commands.add("-i");
+        commands.add(bgVideo);
+        commands.add("-filter_complex");
+        String param = "[1:v][0:v]overlay=0:0";
+        commands.add(param);
+//        commands.add("-map 1:a");
+        commands.add("-c:a");
+        commands.add("copy");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("mergeBgVideo,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 去除背景
+     *
+     * @param inputFilePath
+     * @param colorAndSF
+     * @param outputFilePath
+     * @return
+     */
+    public static void removeBg(String inputFilePath, String colorAndSF, String outputFilePath) {
+        // ffmpeg -i green.mp4 -vf "chromakey=0x00FF00:0.2:0.1" -c copy -c:v png out1.mov
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputFilePath);
+        commands.add("-vf");
+        String param = "chromakey={color}";
+        param = param.replace("{color}", colorAndSF);
+        commands.add(param);
+        commands.add("-c");
+        commands.add("copy");
+        commands.add("-c:v");
+        commands.add("png");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("removeBg,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * mov视频转webm
+     *
+     * @param inputFilePath
+     * @param outputFilePath
+     */
+    public static void movToWebm(String inputFilePath, String outputFilePath) {
+        // ffmpeg -i out1.mov -c:v libvpx-vp9 -vf "format=yuva420p" -auto-alt-ref 0 -y out1.webm
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputFilePath);
+        commands.add("-c:v");
+        commands.add("libvpx-vp9");
+        commands.add("-vf");
+        commands.add("format=yuva420p");
+        commands.add("-auto-alt-ref");
+        commands.add("0");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("movToWebm,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 图片转视频
+     *
+     * @param inputImage
+     * @param width
+     * @param height
+     * @param duration       单位：秒
+     * @param outputFilePath
+     */
+    public static void imageToVideo(String inputImage, Integer width, Integer height, String duration, String outputFilePath) {
+        // ffmpeg -r 25 -f image2 -loop 1 -i base_1.png -vcodec libx264 -pix_fmt yuv420p -s 1334x700 -r 25 -t 4 -y out4.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-r");
+        commands.add("25");
+        commands.add("-f");
+        commands.add("image2");
+        commands.add("-loop");
+        commands.add("1");
+        commands.add("-i");
+        commands.add(inputImage);
+        commands.add("-vcodec");
+        commands.add("libx264");
+        commands.add("-pix_fmt");
+        commands.add("yuv420p");
+        commands.add("-s");
+        commands.add(width + "x" + height);
+        commands.add("-r");
+        commands.add("25");
+        commands.add("-t");
+        commands.add(duration);
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("imageToVideo,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 两个音频混合
+     *
+     * @param audio1
+     * @param audio2
+     * @param outputFilePath
+     * @return
+     */
+    public static void mixTwoAudio(String audio1, String audio2, String outputFilePath) {
+        // ffmpeg -i 江南_伴奏_片段.mp3 -i generate.wav -filter_complex amix=inputs=2:duration=longest -y merge.mp3
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(audio1);
+        commands.add("-i");
+        commands.add(audio2);
+        commands.add("-filter_complex");
+        commands.add("amix=inputs=2:duration=longest");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("mixTwoAudio,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 修改音量
+     *
+     * @param inputMedia
+     * @param volumeMultiple
+     * @param outputFilePath
+     * @return
+     */
+    public static void changeMediaVolume(String inputMedia, String volumeMultiple, String outputFilePath) {
+        // ffmpeg -i out1.mp3 -af "volume=1.5" -y out2.mp3
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputMedia);
+        commands.add("-af");
+        commands.add("volume=" + volumeMultiple);
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("changeMediaVolume,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 修改视频音量（视频不编解码）
+     *
+     * @param inputMedia
+     * @param volumeMultiple
+     * @param outputFilePath
+     * @return
+     */
+    public static void changeVideoVolume(String inputMedia, String volumeMultiple, String outputFilePath) {
+        // ffmpeg -i out1.mp3 -af "volume=1.5" -y out2.mp3
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputMedia);
+        commands.add("-c:v");
+        commands.add("copy");
+        commands.add("-af");
+        commands.add("volume=" + volumeMultiple);
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("changeVideoVolume,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 修改音量,使用loudnorm过滤器
+     *
+     * @param inputMedia
+     * @param volumeLUFS
+     * @param outputFilePath
+     * @return
+     */
+    public static void changeMediaVolumeByLoudnorm(String inputMedia, String volumeLUFS, String outputFilePath) {
+        // ffmpeg -i 1.mp3 -af loudnorm=I=-16:TP=-1.5:LRA=11 -y output5.mp3
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputMedia);
+        commands.add("-af");
+        commands.add("loudnorm=I=" + volumeLUFS + ":TP=-1.5:LRA=11");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("changeMediaVolumeByLoudnorm,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 修改视频音量,使用loudnorm过滤器（视频不编解码）
+     *
+     * @param inputMedia
+     * @param volumeLUFS
+     * @param outputFilePath
+     * @return
+     */
+    public static void changeVideoVolumeByLoudnorm(String inputMedia, String volumeLUFS, String outputFilePath) {
+        // ffmpeg -i 1.mp3 -c:v -copy -af loudnorm=I=-16:TP=-1.5:LRA=11 -y output5.mp3
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputMedia);
+        commands.add("-c:v");
+        commands.add("copy");
+        commands.add("-af");
+        commands.add("loudnorm=I=" + volumeLUFS + ":TP=-1.5:LRA=11");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("changeVideoVolumeByLoudnorm,ffmpeg执行失败");
+        }
+    }
+
+
+    /**
+     * 生成静音音频
+     *
+     * @param duration
+     * @param sampleRate
+     * @param coding
+     * @param outputFilePath
+     * @return
+     */
+    public static void generateSilenceAudio(String duration, String sampleRate, String coding, String outputFilePath) {
+        // ffmpeg -f lavfi -t 5 -i anullsrc=r=44100:cl=mono -c:a libopus -y silence.ogg
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-f");
+        commands.add("lavfi");
+        commands.add("-t");
+        commands.add(duration);
+        commands.add("-i");
+        String params = "anullsrc=r=" + sampleRate + ":cl=mono";
+        commands.add(params);
+        commands.add("-c:a");
+        commands.add(coding);
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("generateSilenceAudio,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 在音频开头添加静音时长
+     *
+     * @param duration
+     * @param sampleRate
+     * @param inputAudio
+     * @param outputFilePath
+     */
+    public static void addHeadSilenceToAudio(String duration, String sampleRate, String inputAudio, String outputFilePath) {
+        // ffmpeg -f lavfi -t 10 -i anullsrc=r=44100:cl=mono -i bd464824ae9343538e06eaeddabf3f86.ogg -filter_complex "[0:0][1:0]concat=n=2:v=0:a=1[out]" -map "[out]" -y out5.ogg
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-f");
+        commands.add("lavfi");
+        commands.add("-t");
+        commands.add(duration);
+        commands.add("-i");
+        String params1 = "anullsrc=r=" + sampleRate + ":cl=mono";
+        commands.add(params1);
+        commands.add("-i");
+        commands.add(inputAudio);
+        commands.add("-filter_complex");
+        commands.add("[0:0][1:0]concat=n=2:v=0:a=1[out]");
+        commands.add("-map");
+        commands.add("[out]");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("addHeadSilenceToAudio,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * @param inputAudio
+     * @param coding
+     * @param outputFilePath
+     */
+    public static void audioTranscoding(String inputAudio, String coding, String outputFilePath) {
+        // ffmpeg -i input.ogg -c:a libopus output.opus
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputAudio);
+        commands.add("-c:a");
+        commands.add(coding);
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("audioTranscoding,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 视频转码
+     *
+     * @param inputVideo
+     * @param coding
+     * @param outputFilePath
+     */
+    public static void videoTranscoding(String inputVideo, String coding, String bitrate, String outputFilePath) {
+        // ffmpeg -i 13.mp4 -c:v libx264 -b:v 2000k -y out13.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputVideo);
+        if (StringUtils.hasText(coding)) {
+            commands.add("-c:v");
+            commands.add(coding);
+        }
+        if (StringUtils.hasText(bitrate)) {
+            commands.add("-b:v");
+            commands.add(bitrate);
+        }
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("videoTranscoding,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 视频贴图
+     */
+    public static void videoTexture(String videoPath, String imagePath,
+                                    Integer x, Integer y, String outputFilePath) {
+        // ffmpeg -i 25.mp4 -i 2.png -filter_complex "[0:v][1:v]overlay=0:0[out]" -map "[out]" -map 0:a -c:v libx264 -preset ultrafast -crf 28 -c:a copy -y output_3.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(videoPath);
+        commands.add("-i");
+        commands.add(imagePath);
+        commands.add("-filter_complex");
+        commands.add(String.format("[0:v][1:v]overlay=%s:%s[out]", x, y));
+        commands.add("-map");
+        commands.add("[out]");
+        commands.add("-map");
+        commands.add("0:a");
+        commands.add("-c:v");
+        commands.add("libx264");
+        commands.add("-preset");
+        commands.add("superfast");
+        commands.add("-crf");
+        commands.add("28");
+        commands.add("-c:a");
+        commands.add("copy");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("videoTexture,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 修复视频时间戳
+     *
+     * @param inputVideo
+     * @param outputFilePath
+     * @return
+     */
+    public static void fixVideoTime(String inputVideo, String outputFilePath) {
+        // ffmpeg -i input.mp4 -c copy -video_track_timescale 30k -avoid_negative_ts make_zero -y output.mp4
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-c");
+        commands.add("copy");
+        commands.add("-video_track_timescale");
+        commands.add("30k");
+        commands.add("-avoid_negative_ts");
+        commands.add("make_zero");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("fixVideoTime,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 重新编码
+     *
+     * @param inputVideo
+     * @param outputFilePath
+     * @return
+     */
+    public static void encodingEquivalence(String inputVideo, String outputFilePath) {
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-r");
+        commands.add("30");
+//        commands.add("-s");
+//        commands.add("720x1280");
+        commands.add("-c:v");
+        commands.add("libx264");
+        commands.add("-preset");
+        commands.add("superfast");
+        commands.add("-c:a");
+        commands.add("aac");
+        commands.add("-ar");
+        commands.add("44100");
+        commands.add("-ac");
+        commands.add("2");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("encodingEquivalence,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 取视频最后一帧
+     *
+     * @param inputVideo
+     * @param outputFilePath
+     * @return
+     */
+    public static void getVideoLastFrame(String inputVideo, int lastTime, String outputFilePath) {
+        // ffmpeg -sseof -2 -i input.mp4 -update 1 -q:v 1 -y last_frame.jpg
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-sseof");
+        commands.add("-" + lastTime);
+        commands.add("-i");
+        commands.add(inputVideo);
+        commands.add("-update");
+        commands.add("1");
+        commands.add("-q:v");
+        commands.add("1");
+        commands.add("-y");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("getVideoLastFrame,ffmpeg执行失败");
+        }
+    }
+
+    // ffmpeg -i input.mp3 -af "afftdn=nf=-20,volume=2" -codec:a libmp3lame -b:a 128k -ar 44100 -ac 2 output.mp3
+    public static void audioVolume(String inputFilePath, String outputFilePath, String afParam) {
+        List<String> commands = new ArrayList<>();
+        commands.add("ffmpeg");
+        commands.add("-i");
+        commands.add(inputFilePath);
+        commands.add("-af");
+        commands.add(afParam);
+        commands.add("-codec:a");
+        commands.add("libmp3lame");
+        commands.add("-b:a");
+        commands.add("128k");
+        commands.add("-ar");
+        commands.add("44100");
+        commands.add("-ac");
+        commands.add("2");
+        commands.add(outputFilePath);
+        FFmpegCommandResult ffmpegResult = executeFFmpegCommand(commands);
+        if (!ffmpegResult.isSuccessful()) {
+            throw new FFmpegExecuteException("audioVolume,ffmpeg执行失败");
+        }
+    }
+
+    /**
+     * 执行ffmpeg命令
+     *
+     * @param commands
+     * @return
+     */
+    public static FFmpegCommandResult executeFFmpegCommand(List<String> commands) {
+        long beginTime = System.currentTimeMillis();
+        FFmpegCommandResult result = new FFmpegCommandResult();
+        String commandStr = "";
+        for (String command : commands) {
+            commandStr = commandStr + command + " ";
+        }
+        commandStr = commandStr.trim();
+        Runtime runtime = Runtime.getRuntime();
+        Process process = null;
+        try {
+            ProcessBuilder processBuilder = new ProcessBuilder();
+            processBuilder.command(commands);
+            processBuilder.redirectErrorStream(true);
+            process = processBuilder.start();
+            log.info("开始执行ffmpeg命令,command:{},线程名:{}", commandStr, process.toString());
+            String resultContent = IOUtils.toString(process.getInputStream(), "utf-8");
+            int exitCode = process.waitFor();
+            result.setExitCode(exitCode);
+            result.setResultContent(resultContent);
+            log.info("ffmpeg命令执行结束,command:\n{}\nexpendTime:{},exitCode:{},result:\n{}", commandStr,
+                    (System.currentTimeMillis() - beginTime), exitCode, resultContent);
+        } catch (Exception e) {
+            log.info("ffmpeg命令执行异常,command:{}", commandStr, e);
+            result.setExitCode(-999);
+        } finally {
+            if (Objects.nonNull(process)) {
+                process.destroy();
+                log.info("已销毁FFmpeg进程进程名:{}", process.toString());
+//                ProcessKiller processKiller = new ProcessKiller(process);
+//                // JVM退出时，先通过钩子关闭FFmepg进程
+//                runtime.addShutdownHook(processKiller);
+            }
+        }
+        return result;
+    }
+
+    public static String pathCreate(String path) {
+        File file = new File(path);
+        if (!file.getParentFile().exists()) {
+            file.getParentFile().mkdirs();
+        }
+        return path;
+    }
+
+    public static List<String> ls(String path) {
+        if (!StringUtils.hasText(path)) {
+            return new ArrayList<>();
+        }
+
+        try (Stream<Path> paths = Files.walk(Paths.get(path))) {
+            return paths.filter(Files::isRegularFile) // 只要文件
+                    .map(Path::toAbsolutePath)    // 转绝对路径
+                    .map(Path::toString)          // 转成字符串
+                    .collect(Collectors.toList());
+        } catch (IOException e) {
+            log.error("FFmpegUtil.ls error. path: {},\n", path, e);
+        }
+
+        return new ArrayList<>();
+    }
+
+    /**
+     * 在程序退出前结束已有的FFmpeg进程
+     */
+    private static class ProcessKiller extends Thread {
+        private Process process;
+
+        public ProcessKiller(Process process) {
+            this.process = process;
+        }
+
+        @Override
+        public void run() {
+            this.process.destroy();
+            log.info("已销毁FFmpeg进程进程名:{}", process.toString());
+        }
+    }
+
+    private static Integer parseAndCalcAvgFrameRate(String avgFrameRateStr) {
+        try {
+            String[] split = avgFrameRateStr.split("/");
+            if (split.length != 2) {
+                return null;
+            }
+            double d0 = Double.parseDouble(split[0].trim());
+            double d1 = Double.parseDouble(split[1].trim());
+            return (int) Math.ceil(d0 / d1);
+        } catch (Exception e) {
+            log.error("parseAndCalcAvgFrameRate error: {} \n", avgFrameRateStr, e);
+        }
+        return null;
+    }
+
+    private static Integer parseAndCalcTimeBase(String timeBaseStr) {
+        try {
+            String[] split = timeBaseStr.split("/");
+            if (split.length != 2) {
+                return null;
+            }
+            return Integer.parseInt(split[1].trim());
+        } catch (Exception e) {
+            log.error("parseAndCalcTimeBase error: {} \n", timeBaseStr, e);
+        }
+        return null;
+    }
+
+    @Getter
+    @Setter
+    @Accessors(chain = true)
+    public static class MediaInfo {
+        private Integer width;
+        private Integer height;
+        // 毫秒
+        private Integer duration;
+        // Byte
+        private Integer size;
+        // 音频采样率
+        private Integer sampleRate;
+        // 视频平均帧率
+        private Integer avgFrameRate;
+        // 时间基
+        private Integer timeBase;
+    }
+
+    @Getter
+    @Setter
+    @Accessors(chain = true)
+    public static class FFmpegCommandResult {
+        // 0 表示命令正常结束
+        private int exitCode = -1;
+        private String resultContent;
+
+        public boolean isSuccessful() {
+            return exitCode == 0;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+//        String mediaUrl = "/Users/liuzhiheng/test/video/out6.mp4";
+//        MediaInfo mediaInfo = getMediaInfo(mediaUrl);
+//        System.out.println(JSON.toJSONString(mediaInfo));
+
+//        String inputVideo = "/Users/liuzhiheng/test/video/6.mp4";
+//        String outputFilePath = "/Users/liuzhiheng/test/video/7.mp4";
+//        String startTime = "00:00:02.000";
+//        String endTime = "3.900";
+//        cutVideo(inputVideo, startTime, endTime, outputFilePath);
+
+//        String inputAudio = "/Users/liuzhiheng/test/video/2.mp3";
+//        String outputFilePath = "/Users/liuzhiheng/test/video/output3.mp3";
+//        String startTime = "00:00:04.766";
+//        String endTime = "2.967";
+//        cutAudio(inputAudio, startTime, endTime, outputFilePath);
+
+//        System.out.println(buildMultipleAtempoParams(new StringBuilder(), 0.61));
+
+//        String inputVideo = "/Users/liuzhiheng/test/video/1.mp4";
+//        String outputFilePath = "/Users/liuzhiheng/test/video/output.mp4";
+//        multipleVideo(inputVideo, 3.24, outputFilePath);
+
+//        String inputVideo = "/Users/liuzhiheng/test/video/2.mp4";
+//        String outputFilePath = "/Users/liuzhiheng/test/video/output.mp4";
+//        reverseVideo(inputVideo, outputFilePath);
+
+//        String concatVideosFilePath = "/Users/liuzhiheng/test/video/filelist.txt";
+//        String outputFilePath = "/Users/liuzhiheng/test/video/output.mp4";
+//        concatVideos(concatVideosFilePath, outputFilePath);
+
+//        String inputVideo = "/Users/liuzhiheng/test/video/7.mp4";
+//        String inputAudio = "/Users/liuzhiheng/test/video/3.mp3";
+//        String outputFilePath = "/Users/liuzhiheng/test/video/output.mp4";
+//        videoAmixAudioLoopVideoAndShortest(inputVideo, inputAudio, outputFilePath, 1);
+
+//        String inputVideo = "/Users/liuzhiheng/test/video/6.mp4";
+////        String clipParams = "scale=900:900,pad=900:1600:0:350:black";
+//        String clipParams = "scale=1080:-1,crop=1080:1080:0:420";
+////        String clipParams = "scale=755:-1";
+//        String outputFilePath = "/Users/liuzhiheng/test/video/output.mp4";
+//        clipVideo(inputVideo, clipParams, outputFilePath);
+
+//        String inputVideo = "/Users/liuzhiheng/test/video/6.mp4";
+//        String inputSubtitleAndStyle = "subtitles=/Users/liuzhiheng/test/video/2.ass";
+////                + ":force_style='Fontsize=12,Alignment=2,MarginV=68'";
+//        String outputFilePath = "/Users/liuzhiheng/test/video/output2.mp4";
+//        addSubtitle(inputVideo, inputSubtitleAndStyle, outputFilePath);
+
+//        generateBlackVideo(1920, 1080, "10.333", "/Users/liuzhiheng/test/video/output5.mp4");
+
+//        String bgVideo = "/Users/liuzhiheng/test/video/bg.mp4";
+//        String mainVideo = "/Users/liuzhiheng/test/video/out1.mov";
+//        mergeBgVideo(mainVideo, bgVideo, "/Users/liuzhiheng/test/video/out1.mp4");
+
+//        String inputImage = "/Users/liuzhiheng/test/video/111.mp4";
+//        imageToVideo(inputImage, 1334, 700, 5, "/Users/liuzhiheng/test/video/out7.mp4");
+
+//        String inputFilePath = "/Users/liuzhiheng/test/video/green.mp4";
+//        removeBg(inputFilePath, "0x00FF00", "/Users/liuzhiheng/test/video/out5.mov");
+
+//        String inputMedia = "/Users/liuzhiheng/test/video/6.mp4";
+//        changeVideoVolume(inputMedia, "0.6", "/Users/liuzhiheng/test/video/out4.mp4");
+
+//        generateSilenceAudio("10.521", "44100", "/Users/liuzhiheng/Downloads/out1.ogg");
+
+//        addHeadSilenceToAudio("3.566", "44100", "/Users/liuzhiheng/Downloads/1.ogg", "/Users/liuzhiheng/Downloads/out2.ogg");
+
+//        String inputVideo = "/Users/liuzhiheng/test/video/out1.mov";
+//        movToWebm(inputVideo, "/Users/liuzhiheng/test/video/out1-3.webm");
+
+//        String videoUrl = "http://res.cybertogether.net/crawler/video/c8adfa2f63943d6f69a484120dfb798b.mp4";
+//        String time = "10";
+//        String outputFilePath = "/Users/liuzhiheng/test/video/out_image_6.jpg";
+//        getTimeImage(videoUrl, time, outputFilePath, 1);
+
+//        String inputVideo = "/Users/liuzhiheng/test/video/concat/01.mp4";
+//        String outputFilePath = "/Users/liuzhiheng/test/video/concat/01_time.mp4";
+//        fixVideoTime(inputVideo, outputFilePath);
+
+//        String inputVideo = "/Users/liuzhiheng/test/video/6.mp4";
+//        String outputFilePath = "/Users/liuzhiheng/test/video/output2.mp4";
+//        videoTranscoding(inputVideo, "libx264","1000k", outputFilePath);
+
+//        String inputMedia = "/Users/liuzhiheng/test/video/6.mp4";
+//        String volumeLUFS = "-16";
+//        String outputFilePath = "/Users/liuzhiheng/test/video/out2.mp4";
+//        changeVideoVolumeByLoudnorm(inputMedia, volumeLUFS, outputFilePath);
+
+//        String videoPath = "/Users/liuzhiheng/test/video/25.mp4";
+//        String imagePath = "/Users/liuzhiheng/test/video/2.png";
+//        Integer x = 0;
+//        Integer y = 0;
+//        String outputFilePath = "/Users/liuzhiheng/test/video/output4.mp4";
+//        videoTexture(videoPath, imagePath, x, y, outputFilePath);
+
+//        String inputMedia = "/Users/liuzhiheng/test/video/6.mp4";
+//        encodingEquivalence(inputMedia, "/Users/liuzhiheng/test/video/out7.mp4");
+
+        String inputVideo = "/Users/liuzhiheng/test/video/concat/4.mp4";
+        String clipParams = "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2";
+        String outputFilePath = "/Users/liuzhiheng/test/video/concat/4_clip.mp4";
+        clipAndTranscodeVideo(inputVideo, clipParams, outputFilePath, null, null);
+    }
+}

src/main/java/com/tzld/ffmpeg/util/FileUtils.java

@@ -0,0 +1,30 @@
+package com.tzld.ffmpeg.util;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public class FileUtils {
+
+    public static void deleteFileByIO(String filePath) {
+        File file = new File(filePath);
+        File[] list = file.listFiles();
+        if (list != null) {
+            for (File temp : list) {
+                deleteFileByIO(temp.getAbsolutePath());
+            }
+        }
+        file.delete();
+    }
+
+    public static void saveFileContent(String filePath, byte[] contentBytes) throws IOException {
+        Path path = Paths.get(filePath);
+        Path parentDir = path.getParent();
+        if (!Files.exists(parentDir)) {
+            Files.createDirectories(parentDir);
+        }
+        Files.write(path, contentBytes);
+    }
+}

src/main/java/com/tzld/ffmpeg/util/IpUtil.java

@@ -0,0 +1,69 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright © 2021 xrv <xrg@live.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.tzld.ffmpeg.util;
+
+import javax.servlet.http.HttpServletRequest;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+/**
+ * @author ehlxr
+ * @since 2021-12-14 15:27.
+ */
+public class IpUtil {
+    public static String getIpAddr(HttpServletRequest request) {
+        String ipAddress;
+        ipAddress = request.getHeader("x-forwarded-for");
+        if (ipAddress == null || ipAddress.length() == 0
+                || "unknown".equalsIgnoreCase(ipAddress)) {
+            ipAddress = request.getHeader("Proxy-Client-IP");
+        }
+        if (ipAddress == null || ipAddress.length() == 0
+                || "unknown".equalsIgnoreCase(ipAddress)) {
+            ipAddress = request.getHeader("WL-Proxy-Client-IP");
+        }
+        if (ipAddress == null || ipAddress.length() == 0
+                || "unknown".equalsIgnoreCase(ipAddress)) {
+            ipAddress = request.getRemoteAddr();
+            if ("127.0.0.1".equals(ipAddress)) {
+                // 根据网卡取本机配置的IP
+                InetAddress inet;
+                try {
+                    inet = InetAddress.getLocalHost();
+                    ipAddress = inet.getHostAddress();
+                } catch (UnknownHostException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+        // 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
+        if (ipAddress != null && ipAddress.length() > 15) { // "***.***.***.***".length()
+            if (ipAddress.indexOf(",") > 0) {
+                ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
+            }
+        }
+        return ipAddress;
+    }
+}

src/main/java/com/tzld/ffmpeg/util/PropertiesUtils.java

@@ -0,0 +1,175 @@
+package com.tzld.ffmpeg.util;
+
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.yaml.snakeyaml.Yaml;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Map;
+import java.util.Properties;
+
+@Slf4j
+public class PropertiesUtils {
+    public static Properties properties;
+    public static Properties mainProperties;
+
+    static {
+        mainProperties = new Properties();
+        properties = new Properties();
+        try {
+            // 加载主配置文件 application.yml
+            InputStream mainStream = PropertiesUtils.class.getClassLoader().getResourceAsStream("application.yml");
+            if (mainStream == null) {
+                throw new IOException("application.yml 配置文件不存在");
+            }
+            // 解析 YAML 并转换为 Properties 格式（扁平 key-value）
+            Map<String, Object> mainYamlMap = new Yaml().load(mainStream);
+            mainProperties = convertYamlToProperties(mainYamlMap);
+
+            // 获取环境变量（优先取 -Denv，其次取 application.yml 中的 spring.profiles.active）
+            String env = System.getProperty("env");
+            if (StringUtils.isEmpty(env)) {
+                env = mainProperties.getProperty("spring.profiles.active");
+            }
+            if (StringUtils.isEmpty(env)) {
+                log.error("请设置 spring.profiles.active 或启动参数 -Denv");
+                System.exit(1);
+            }
+
+            // 加载环境配置文件 application-{env}.yml
+            InputStream activeStream = PropertiesUtils.class.getClassLoader().getResourceAsStream("application-" + env + ".yml");
+            if (activeStream == null) {
+                throw new IOException("application-" + env + ".yml 配置文件不存在");
+            }
+            Map<String, Object> activeYamlMap = new Yaml().load(activeStream);
+            Properties activeProperties = convertYamlToProperties(activeYamlMap);
+
+            // 合并配置（环境配置覆盖主配置）
+            properties.putAll(mainProperties);
+            properties.putAll(activeProperties);
+            properties.setProperty("spring.profiles.active", env); // 确保环境变量生效
+            log.info("开发环境为: " + env);
+
+        } catch (IOException e) {
+            log.error("配置文件加载失败: " + e.getMessage(), e);
+            System.exit(1);
+        }
+    }
+
+    /**
+     * 将 YAML 解析后的嵌套 Map 转换为扁平的 Properties（键名用点分隔层级）
+     * 例如: {oss: {ffmpeg: {accessKey: "xxx"}}} → "oss.ffmpeg.accessKey" = "xxx"
+     */
+    private static Properties convertYamlToProperties(Map<String, Object> yamlMap) {
+        Properties properties = new Properties();
+        flattenYamlMap(yamlMap, "", properties);
+        return properties;
+    }
+
+    /**
+     * 递归展平 YAML Map
+     */
+    private static void flattenYamlMap(Map<String, Object> yamlMap, String parentKey, Properties properties) {
+        for (Map.Entry<String, Object> entry : yamlMap.entrySet()) {
+            String key = parentKey.isEmpty() ? entry.getKey() : parentKey + "." + entry.getKey();
+            Object value = entry.getValue();
+
+            if (value instanceof Map<?, ?>) {
+                // 递归处理嵌套 Map
+                flattenYamlMap((Map<String, Object>) value, key, properties);
+            } else if (value instanceof Iterable<?>) {
+                // 处理列表（转换为逗号分隔的字符串）
+                StringBuilder sb = new StringBuilder();
+                for (Object item : (Iterable<?>) value) {
+                    if (sb.length() > 0) sb.append(",");
+                    sb.append(item);
+                }
+                properties.setProperty(key, sb.toString());
+            } else {
+                // 基本类型直接设置
+                properties.setProperty(key, value != null ? value.toString() : "");
+            }
+        }
+    }
+
+    public static Properties getProperties() {
+        return properties;
+    }
+
+    public static String getProjectEnv() {
+        return getProperties().getProperty("spring.profiles.active");
+    }
+
+    public static String getValue(String key) {
+        return PropertiesUtils.getProperties().getProperty(key);
+    }
+
+    public static boolean getSwaggerEnabled() {
+        return Boolean.parseBoolean(getProperties().getProperty("swagger.enabled"));
+    }
+
+    public static String getSwaggerBasePath() {
+        return getProperties().getProperty("swagger.basePath");
+    }
+
+    public static String getSwaggerProtocols() {
+        return getProperties().getProperty("swagger.protocols");
+    }
+
+    public static String getDownloadDomain() {
+        return getProperties().getProperty("oss.longvideo.cdnDomain");
+    }
+
+    public static String getTranscodeLocation() {
+        return getProperties().getProperty("oss.longvideo.transcode.location");
+    }
+
+    public static String getTranscodePipelineId() {
+        return getProperties().getProperty("oss.longvideo.transcode.PipelineId");
+    }
+
+    public static String getReadOnlyAccessKeyId() {
+        return getProperties().getProperty("oss.video.readonly.accessKey");
+    }
+
+    public static String getReadOnlyAccessKeySecret() {
+        return getProperties().getProperty("oss.video.readonly.secretKey");
+    }
+
+    public static Properties getMainProperties() {
+        return mainProperties;
+    }
+
+    public static String getMainPropertiesValue(String key) {
+        return getMainProperties().getProperty(key);
+    }
+
+    public static String getVideoBucket() {
+        return getMainProperties().getProperty("oss.video.bucket");
+    }
+
+    public static String getLongvideoStsEndpoint() {
+        return getMainProperties().getProperty("oss.longvideo.video.sts.endpoint");
+    }
+
+    public static String getLongvideoStsAccessKeyId() {
+        return getMainProperties().getProperty("oss.longvideo.video.sts.accessKeyId");
+    }
+
+    public static String getLongvideoStsAccessKeySecret() {
+        return getMainProperties().getProperty("oss.longvideo.video.sts.accessKeySecret");
+    }
+
+    public static String getLongvideoStsRoleArn() {
+        return getMainProperties().getProperty("oss.longvideo.video.sts.roleArn");
+    }
+
+    public static String getLongvideoStsSessionName() {
+        return getMainProperties().getProperty("oss.longvideo.video.sts.roleSessionName");
+    }
+
+    public static String getOssaccelerateUploadDomain() {
+        return getMainProperties().getProperty("oss.accelerate.upload.domain");
+    }
+}

src/main/java/com/tzld/ffmpeg/util/RandomUtil.java

@@ -0,0 +1,64 @@
+package com.tzld.ffmpeg.util;
+
+import java.math.BigDecimal;
+import java.util.Calendar;
+import java.util.Random;
+import java.util.UUID;
+
+public class RandomUtil {
+
+	public static final String ALLNUMBER = "0123456789";  
+	public static final String ALLCHAR = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";  
+	public static final Integer FIXLENG=18;
+    /** 
+     * 返回一个定长的随机字符串(只包含大小写字母、数字)
+     *  随机字符串长度
+     * @return 随机字符串 
+     */  
+    public static String generate18String() {  
+        StringBuffer sb = new StringBuffer();  
+        Random random = new Random();  
+        for (int i = 0; i < FIXLENG; i++) {  
+            sb.append(ALLCHAR.charAt(random.nextInt(ALLCHAR.length())));  
+        }  
+        return sb.toString();  
+    } 
+    
+    public static void main(String[] args) {
+		//System.out.println(generate18String())
+        String proportion="0.01";
+        Long price=150l;
+        Double incomeMoney=price*(Double.valueOf(proportion));
+        System.out.println(incomeMoney);
+
+
+        BigDecimal b = new BigDecimal(incomeMoney);
+        Long t = b.setScale(0,BigDecimal.ROUND_HALF_UP).longValue();
+        System.out.println(t);
+
+    	
+	}
+    
+    public static String generateString(int length) {  
+        StringBuffer sb = new StringBuffer();  
+        Random random = new Random();  
+        for (int i = 0; i < length; i++) {  
+            sb.append(ALLCHAR.charAt(random.nextInt(ALLCHAR.length())));  
+        }  
+        return sb.toString();  
+    }
+    
+    public static String generateNumber(int length) {  
+        StringBuffer sb = new StringBuffer();  
+        Random random = new Random();  
+        for (int i = 0; i < length; i++) {  
+            sb.append(ALLNUMBER.charAt(random.nextInt(ALLNUMBER.length())));  
+        }  
+        return sb.toString();  
+    } 
+    
+    public static String getRandomUUIDStr() {
+		return UUID.randomUUID().toString().replaceAll("-", "")+Calendar.getInstance().getTimeInMillis();
+	}
+
+}

src/main/java/com/tzld/ffmpeg/util/RedisUtils.java

@@ -0,0 +1,257 @@
+package com.tzld.ffmpeg.util;
+
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.redis.core.RedisCallback;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.RedisSerializer;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+@Service
+public class RedisUtils {
+
+    private final static Logger log = LoggerFactory.getLogger(RedisUtils.class);
+
+    public final static Long DEFAULT_EXPIRE_TIME = 7L * 24 * 60 * 60; // 默认过期7天,单位秒
+
+    @Autowired
+    private RedisTemplate<String, String> redisTemplate;
+
+
+    public boolean containsKey(String key) {
+        if (StringUtils.isBlank(key)) {
+            log.error("containsKey is empty key:" + key);
+            return Boolean.FALSE;
+        }
+        return Boolean.TRUE.equals(redisTemplate.hasKey(key));
+    }
+
+    public String getString(String key) {
+        Object obj = redisTemplate.opsForValue().get(key);
+        return Objects.isNull(obj) ? null : obj.toString();
+    }
+
+    public Long getLong(String key) {
+        long longVal = 0L;
+        Object obj = redisTemplate.opsForValue().get(key);
+        if (Objects.nonNull(obj)) {
+            try {
+                longVal = Long.parseLong(obj.toString());
+            } catch (Exception e) {
+                e.printStackTrace();
+                return longVal;
+            }
+
+        }
+        return longVal;
+    }
+
+    public void setValueWithExpire(String key, String value, Long expireTime) {
+        redisTemplate.opsForValue().set(key, value, expireTime, TimeUnit.SECONDS);
+    }
+
+    public void setIncrementValue(String key, long value, Date date) {
+        Long expireTime;
+        if (date != null) {
+            expireTime = (date.getTime() - System.currentTimeMillis()) / 1000;
+            if (expireTime < 0) {
+                expireTime = DEFAULT_EXPIRE_TIME;
+            }
+        } else { // date为null
+            expireTime = DEFAULT_EXPIRE_TIME;
+        }
+        // 只在第一次进行设置过期时间
+        if (!containsKey(key)) {
+            redisTemplate.opsForValue().increment(key, value);
+            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
+        } else {
+            redisTemplate.opsForValue().increment(key, value);
+        }
+    }
+
+    public void setIncrementValue(String key, Integer value, Long expireTime) {
+        // 只在第一次进行设置过期时间
+        if (!containsKey(key)) {
+            redisTemplate.opsForValue().increment(key, value);
+            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
+        } else {
+            redisTemplate.opsForValue().increment(key, value);
+        }
+    }
+
+    public void setDecrementValue(String key, double value) {
+        redisTemplate.opsForValue().increment(key, -value);
+    }
+
+    public void setIncrementValue(String key, double value, Date date) {
+        Long expireTime;
+        if (date != null) {
+            expireTime = (date.getTime() - System.currentTimeMillis()) / 1000;
+            if (expireTime < 0) {
+                expireTime = DEFAULT_EXPIRE_TIME;
+            }
+        } else { // date为null
+            expireTime = DEFAULT_EXPIRE_TIME;
+        }
+        // 只在第一次进行设置过期时间
+        if (!containsKey(key)) {
+            redisTemplate.opsForValue().increment(key, value);
+            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
+        } else {
+            redisTemplate.opsForValue().increment(key, value);
+        }
+    }
+
+    public int getInteger(String key) {
+        Object obj = redisTemplate.opsForValue().get(key);
+        if (Objects.isNull(obj)) {
+            return 0;
+        }
+        return Integer.valueOf(obj.toString());
+    }
+
+    public Integer getIntegerO(String key) {
+        Object obj = redisTemplate.opsForValue().get(key);
+        if (Objects.isNull(obj)) {
+            return null;
+        }
+        return Integer.valueOf(obj.toString());
+    }
+
+    public void putDealyQueueMsg(String key, String value) {
+        redisTemplate.opsForZSet().add(key, value, System.currentTimeMillis() + DEFAULT_EXPIRE_TIME);
+    }
+
+    public Set<String> processDelayQueue(String key) {
+        long currentTimeMillis = System.currentTimeMillis();
+        Set<String> values = redisTemplate.opsForZSet().rangeByScore(key, 0, currentTimeMillis);
+        if (!CollectionUtils.isEmpty(values)) {
+            redisTemplate.opsForZSet().removeRangeByScore(key, 0, currentTimeMillis);
+        }
+        return values;
+    }
+
+    public void addVal(String key, String val) {
+        redisTemplate.opsForValue().set(key, val);
+    }
+
+    public Long getKeyExpire(String key) {
+        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
+    }
+
+    public void expire(String key, Long time) {
+        redisTemplate.expire(key, time, TimeUnit.SECONDS);
+    }
+
+    public Long countExistingKeys(List<String> keys) {
+        return redisTemplate.countExistingKeys(keys);
+    }
+
+    public boolean del(String key) {
+        return redisTemplate.delete(key);
+    }
+
+    public boolean set(String key, String value, long time) {
+        try {
+            if (time > 0) {
+                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
+            } else {
+                redisTemplate.opsForValue().set(key, value);
+            }
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * Redis 分布式锁
+     *
+     * @param key        锁键
+     * @param value      锁值，可以为随机数或者 UUID 等唯一标识符
+     * @param expireTime 锁过期时间，单位为秒
+     * @return true：获取锁成功，false：获取锁失败
+     */
+    public boolean tryLock(String key, String value, long expireTime) {
+        Boolean result = redisTemplate.opsForValue().setIfAbsent(key, value, expireTime, TimeUnit.SECONDS);
+        if (result != null && result) {
+            // 获取锁成功
+            return true;
+        }
+        return false;
+    }
+
+    public void listLeftPush(String key, String value) {
+        redisTemplate.opsForList().leftPush(key, value);
+
+    }
+
+    public String listRightPop(String key) {
+        return redisTemplate.opsForList().rightPop(key);
+    }
+
+    public Double getDouble(String key) {
+        try {
+            String val = redisTemplate.opsForValue().get(key);
+            if (StringUtils.isNotBlank(val)) {
+                return Double.valueOf(val);
+            }
+        } catch (Exception e) {
+            log.error("getDouble error redis key:" + key + "----" + e);
+        }
+        return null;
+    }
+
+    public String get(String key) {
+        String val = redisTemplate.opsForValue().get(key);
+        if (StringUtils.isNotBlank(val)) {
+            return val;
+        }
+        return null;
+    }
+
+    public void sAdd(String key, String val) {
+        redisTemplate.opsForSet().add(key, val);
+    }
+
+    public Set<String> sMembers(String key) {
+        return redisTemplate.opsForSet().members(key);
+    }
+
+
+    public Boolean sIsMember(String key, String val) {
+        return redisTemplate.opsForSet().isMember(key, val);
+    }
+
+    public void setBit(String key, long val, boolean flag) {
+        redisTemplate.opsForValue().setBit(key, val, flag);
+    }
+
+    public void setBitList(String key, Set<Long> indexs, boolean flag) {
+        RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
+        redisTemplate.executePipelined((RedisCallback<Object>) redisConnection -> {
+            indexs.forEach(x -> {
+                redisConnection.setBit(key.getBytes(), x, flag);
+            });
+            return null;
+        }, serializer);
+    }
+
+    public Boolean getBitMap(String key, long offset) {
+        return redisTemplate.opsForValue().getBit(key, offset);
+    }
+
+    public List<String> mGet(List<String> keys) {
+        return redisTemplate.opsForValue().multiGet(keys);
+    }
+}

src/main/java/com/tzld/ffmpeg/util/TimelineUtils.java

@@ -0,0 +1,55 @@
+package com.tzld.ffmpeg.util;
+
+public class TimelineUtils {
+
+    public static void main(String[] args) {
+        System.out.println(coverSrtTimeToMillis("00:00:00.000", "\\."));
+    }
+
+    // 00:01:57,230 时间格式转成毫秒
+    public static int coverSrtTimeToMillis(String srtTime, String splitMs) {
+        String[] array = srtTime.split(splitMs);
+        String[] hhmmss = array[0].split(":");
+        return Integer.valueOf(hhmmss[0]) * 60 * 60 * 1000 + Integer.valueOf(hhmmss[1]) * 60 * 1000
+                + Integer.valueOf(hhmmss[2]) * 1000 + Integer.valueOf(array[1]);
+    }
+
+    public static String convertMillisToStringTime(int millis, String splitSSS) {
+        String hh = "";
+        int hhInt = 0;
+        String mm = "";
+        int mmInt = 0;
+        String ss = "";
+        int ssInt = millis / 1000;
+        String SSS = millis % 1000 + "";
+        if (ssInt >= 60) {
+            mmInt = ssInt / 60;
+            ss = ssInt % 60 + "";
+        } else {
+            ss = ssInt + "";
+        }
+        if (mmInt >= 60) {
+            hhInt = mmInt / 60;
+            mm = mmInt % 60 + "";
+        } else {
+            mm = mmInt + "";
+        }
+        hh = hhInt + "";
+        // 补0
+        if (SSS.length() == 1) {
+            SSS = "00" + SSS;
+        } else if (SSS.length() == 2) {
+            SSS = "0" + SSS;
+        }
+        if (ss.length() == 1) {
+            ss = "0" + ss;
+        }
+        if (mm.length() == 1) {
+            mm = "0" + mm;
+        }
+        if (hh.length() == 1) {
+            hh = "0" + hh;
+        }
+        return hh + ":" + mm + ":" + ss + splitSSS + SSS;
+    }
+}

src/main/java/com/tzld/ffmpeg/util/http/CurlUtils.java

@@ -0,0 +1,54 @@
+package com.tzld.ffmpeg.util.http;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.util.StringUtils;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class CurlUtils {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(CurlUtils.class);
+
+    public static String execCurl(String url) {
+        String[] cmds = {"curl", "--connect-timeout", "3", "-I", "-v", url};
+        String cmdString = String.join(" ", cmds);
+        System.out.println(cmdString);
+        ProcessBuilder process = new ProcessBuilder(cmds);
+        Process p = null;
+        BufferedReader reader = null;
+        try {
+            p = process.start();
+            reader = new BufferedReader(new InputStreamReader(p.getInputStream()));
+            StringBuilder builder = new StringBuilder();
+            String line;
+            while ((line = reader.readLine()) != null) {
+                builder.append(line);
+                builder.append(System.getProperty("line.separator"));
+            }
+            String result = builder.toString();
+            LOGGER.info("CurlUtils cmd = {} , result = {}", cmdString, StringUtils.hasText(result) ? result : null);
+            return result;
+        } catch (Exception e) {
+            LOGGER.error("CurlUtils error , {}", cmdString, e);
+        } finally {
+            if (p != null) {
+                p.destroy();
+            }
+            if (reader != null) {
+                try {
+                    reader.close();
+                } catch (IOException e) {
+                }
+            }
+        }
+        return null;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(execCurl("https://wwww.baidu.com"));
+    }
+
+}

src/main/java/com/tzld/ffmpeg/util/http/HttpClientUtils.java

@@ -0,0 +1,768 @@
+package com.tzld.ffmpeg.util.http;
+
+import com.alibaba.fastjson.JSONObject;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.http.Consts;
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpHeaders;
+import org.apache.http.NameValuePair;
+import org.apache.http.client.config.RequestConfig;
+import org.apache.http.client.entity.UrlEncodedFormEntity;
+import org.apache.http.client.methods.*;
+import org.apache.http.config.*;
+import org.apache.http.conn.socket.ConnectionSocketFactory;
+import org.apache.http.conn.socket.PlainConnectionSocketFactory;
+import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
+import org.apache.http.entity.ByteArrayEntity;
+import org.apache.http.entity.ContentType;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.entity.mime.HttpMultipartMode;
+import org.apache.http.entity.mime.MultipartEntityBuilder;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
+import org.apache.http.message.BasicNameValuePair;
+import org.apache.http.ssl.SSLContexts;
+import org.apache.http.util.EntityUtils;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.X509TrustManager;
+import java.io.File;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.nio.charset.CodingErrorAction;
+import java.security.KeyManagementException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.*;
+import java.util.Map.Entry;
+
+/**
+ * 基于apache httpclient4.5.5 的HTTP工具类
+ *
+ * @author liuzhiheng
+ * @date 2017-4-7 下午12:10:29
+ * @since 1.0
+ */
+public class HttpClientUtils {
+
+    static Log log = LogFactory.getLog(HttpClientUtils.class);
+
+    private static CloseableHttpClient client;
+    private static RequestConfig requestConfigDefault;
+    private static PoolingHttpClientConnectionManager connManager = null;
+    // 默认请求获取数据的超时时间
+    private static Integer readTimeoutDefault = 150000;
+    // 默认连接超时时间
+    private static Integer connectTimeoutDefault = 50000;
+    // 默认从connectManager获取Connection超时时间
+    private static Integer getConnectionTimeoutDefault = 1000;
+    // 默认的字符集
+    private static String charsetDefault = "UTF-8";
+
+    public static final String contentTypeJson = "application/json";
+    public static final String contentTypeXml = "application/xml";
+
+    private enum MethodType {
+        GET, POST
+    }
+
+    static {
+        try {
+            SSLContext sslContext = SSLContexts.createDefault();
+            sslContext.init(null, new TrustManager[]{new X509TrustManager() {
+
+                public void checkClientTrusted(X509Certificate[] arg0, String arg1)
+                        throws CertificateException {
+                }
+
+                public void checkServerTrusted(X509Certificate[] arg0, String arg1)
+                        throws CertificateException {
+                }
+
+                public X509Certificate[] getAcceptedIssuers() {
+                    return null;
+                }
+            }}, null);
+            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
+                    .register("http", PlainConnectionSocketFactory.INSTANCE)
+                    .register("https", new SSLConnectionSocketFactory(sslContext)).build();
+            connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
+            SocketConfig socketConfig = SocketConfig.custom().setTcpNoDelay(true).build();
+            connManager.setDefaultSocketConfig(socketConfig);
+            MessageConstraints messageConstraints = MessageConstraints.custom().build();
+            ConnectionConfig connectionConfig = ConnectionConfig.custom()
+                    .setMalformedInputAction(CodingErrorAction.IGNORE)
+                    .setUnmappableInputAction(CodingErrorAction.IGNORE).setCharset(Consts.UTF_8)
+                    .setMessageConstraints(messageConstraints).build();
+            connManager.setDefaultConnectionConfig(connectionConfig);
+            connManager.setMaxTotal(1000);
+            connManager.setDefaultMaxPerRoute(500);
+            connManager.setValidateAfterInactivity(3000);
+        } catch (KeyManagementException e) {
+            log.error(e);
+        }
+
+        requestConfigDefault = RequestConfig.custom().setConnectionRequestTimeout(getConnectionTimeoutDefault)
+                .setConnectTimeout(connectTimeoutDefault).setSocketTimeout(readTimeoutDefault).build();
+        client = HttpClients.custom().useSystemProperties().setConnectionManager(connManager).setDefaultRequestConfig(requestConfigDefault)
+                .build();
+
+    }
+
+
+    public static HttpResponseContent head(String url) {
+        HttpRequestBase request = new HttpHead(url);
+        HttpResponseContent hrc = executeHeadHttpRequest(request, connectTimeoutDefault, readTimeoutDefault);
+        return hrc;
+    }
+
+    /**
+     * get请求
+     *
+     * @param url 请求的url
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent get(String url) {
+        return get(url, null, connectTimeoutDefault, readTimeoutDefault, null);
+    }
+
+    /**
+     * @param url     请求的url
+     * @param headers 请求需要携带的header信息
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent get(String url, Map<String, String> headers) {
+        return get(url, null, connectTimeoutDefault, readTimeoutDefault, headers);
+    }
+
+    /**
+     * get请求
+     *
+     * @param url         请求的url
+     * @param contentType contentType，例如：text/plain
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent get(String url, String contentType) {
+        return get(url, contentType, connectTimeoutDefault, readTimeoutDefault, null);
+    }
+
+    /**
+     * get请求
+     *
+     * @param url            请求的url
+     * @param connectTimeout 连接超时设置，毫秒
+     * @param readTimeout    读取超时设置，毫秒
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent get(String url, int connectTimeout, int readTimeout) {
+        return get(url, null, connectTimeout, readTimeout, null);
+    }
+
+    /**
+     * get请求
+     *
+     * @param url            请求的url
+     * @param contentType    contentType，例如：text/plain
+     * @param connectTimeout 连接超时设置，毫秒
+     * @param readTimeout    读取超时设置，毫秒
+     * @param headers        请求需要携带的header信息
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent get(String url, String contentType, int connectTimeout, int readTimeout, Map<String, String> headers) {
+        return getOrPostUrl(MethodType.GET, url, contentType, connectTimeout, readTimeout, headers);
+    }
+
+    /**
+     * post请求，参数在url中
+     *
+     * @param url 请求的url
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent postUrl(String url) {
+        return postUrl(url, null, connectTimeoutDefault, readTimeoutDefault);
+    }
+
+    /**
+     * post请求，参数在url中
+     *
+     * @param url         请求的url
+     * @param contentType contentType，例如：text/plain
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent postUrl(String url, String contentType) {
+        return postUrl(url, contentType, connectTimeoutDefault, readTimeoutDefault);
+    }
+
+    /**
+     * post请求，参数在url中
+     *
+     * @param url            请求的url
+     * @param connectTimeout 连接超时设置，毫秒
+     * @param readTimeout    读取超时设置，毫秒
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent postUrl(String url, int connectTimeout, int readTimeout) {
+        return postUrl(url, null, connectTimeout, readTimeout);
+    }
+
+    /**
+     * post请求，参数在url中
+     *
+     * @param url            请求的url
+     * @param contentType    contentType，例如：text/plain
+     * @param connectTimeout 连接超时设置，毫秒
+     * @param readTimeout    读取超时设置，毫秒
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent postUrl(String url, String contentType, int connectTimeout, int readTimeout) {
+        return getOrPostUrl(MethodType.POST, url, contentType, connectTimeout, readTimeout);
+    }
+
+    /**
+     * get或者post请求，参数在url中
+     *
+     * @param methodType     GET/POST
+     * @param url            请求的url
+     * @param contentType    contentType，例如：text/plain
+     * @param connectTimeout 连接超时设置，毫秒
+     * @param readTimeout    读取超时设置，毫秒
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    private static HttpResponseContent getOrPostUrl(MethodType methodType, String url, String contentType,
+                                                    int connectTimeout, int readTimeout) {
+        return getOrPostUrl(methodType, url, contentType, connectTimeout, readTimeout, null);
+    }
+
+    private static HttpResponseContent getOrPostUrl(MethodType methodType, String url, String contentType,
+                                                    int connectTimeout, int readTimeout, Map<String, String> extHeaders) {
+        HttpRequestBase request = null;
+        HttpResponseContent hrc = null;
+        if (methodType == MethodType.GET) {
+            request = new HttpGet(url);
+        } else {
+            request = new HttpPost(url);
+        }
+        // 设置contentType
+        if (contentType != null) {
+            request.addHeader(HttpHeaders.CONTENT_TYPE, contentType);
+        }
+        //add by nieqi since 2022-3-23
+        if (Objects.nonNull(extHeaders)) {
+            for (String s : extHeaders.keySet()) {
+                if (Objects.nonNull(s)) {
+                    String headerValue = extHeaders.get(s);
+                    if (Objects.nonNull(headerValue)) {
+                        request.addHeader(s, headerValue);
+                    }
+                }
+            }
+        }
+        hrc = executeHttpRequest(request, connectTimeout, readTimeout);
+        return hrc;
+    }
+
+    /**
+     * post请求，请求数据在data中
+     *
+     * @param url  请求的url
+     * @param data 请求数据
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent postData(String url, String data) {
+        return postData(url, data, null, connectTimeoutDefault, readTimeoutDefault);
+
+    }
+
+    /**
+     * post请求，请求数据在data中
+     *
+     * @param url         请求的url
+     * @param data        请求数据
+     * @param contentType contentType，例如：text/plain
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent postData(String url, String data, String contentType) {
+        return postData(url, data, contentType, connectTimeoutDefault, readTimeoutDefault);
+    }
+
+    /**
+     * post请求，请求数据在data中
+     *
+     * @param url            请求的url
+     * @param data           请求数据
+     * @param connectTimeout 连接超时设置，毫秒
+     * @param readTimeout    读取超时设置，毫秒
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent postData(String url, String data, int connectTimeout, int readTimeout) {
+        return postData(url, data, null, connectTimeout, readTimeout);
+    }
+
+    /**
+     * post请求，请求数据在data中
+     *
+     * @param url            请求的url
+     * @param data           请求数据
+     * @param contentType    contentType，例如：text/plain
+     * @param connectTimeout 连接超时设置，毫秒
+     * @param readTimeout    读取超时设置，毫秒
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent postData(String url, String data, String contentType, int connectTimeout,
+                                               int readTimeout) {
+        Map<String, String> headerMap = new HashMap<String, String>();
+        headerMap.put(HttpHeaders.CONTENT_TYPE, contentType);
+        return postDataAddHeader(url, data, headerMap, connectTimeout, readTimeout);
+
+    }
+
+    /**
+     * post请求，请求数据在data中
+     *
+     * @param url            请求的url
+     * @param data           请求数据
+     * @param headerMap      http请求头，key-value放在map中
+     * @param connectTimeout 连接超时设置，毫秒
+     * @param readTimeout    读取超时设置，毫秒
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent postDataAddHeader(String url, String data, Map<String, String> headerMap,
+                                                        int connectTimeout, int readTimeout) {
+        HttpRequestBase request = null;
+        HttpResponseContent hrc = null;
+        HttpPost httpPost = new HttpPost(url);
+        httpPost.setEntity(new StringEntity(data, charsetDefault));
+        request = httpPost;
+        // 设置header
+        if (headerMap != null) {
+            for (Entry<String, String> entry : headerMap.entrySet()) {
+                request.addHeader(entry.getKey(), entry.getValue());
+            }
+        }
+        hrc = executeHttpRequest(request, connectTimeout, readTimeout);
+        return hrc;
+
+    }
+
+    /**
+     * post请求，请求数据在data中
+     *
+     * @param url            请求的url
+     * @param msgpackBytes   请求数据
+     * @param headerMap      http请求头，key-value放在map中
+     * @param connectTimeout 连接超时设置，毫秒
+     * @param readTimeout    读取超时设置，毫秒
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent postMsgpackDataAddHeader(String url, byte[] msgpackBytes, Map<String, String> headerMap,
+                                                        int connectTimeout, int readTimeout) {
+        HttpRequestBase request = null;
+        HttpResponseContent hrc = null;
+        HttpPost httpPost = new HttpPost(url);
+        ByteArrayEntity entity = new ByteArrayEntity(msgpackBytes);
+        entity.setContentType("application/msgpack");
+        httpPost.setEntity(entity);
+        request = httpPost;
+        // 设置header
+        if (headerMap != null) {
+            for (Entry<String, String> entry : headerMap.entrySet()) {
+                request.addHeader(entry.getKey(), entry.getValue());
+            }
+        }
+        hrc = executeHttpRequest(request, connectTimeout, readTimeout);
+        return hrc;
+
+    }
+
+    /**
+     * post请求,form表单,不能包含二进制数据
+     *
+     * @param url       请求的url
+     * @param paramsMap form表单参数map
+     * @param headerMap form表单header
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent postForm(String url, Map<String, String> paramsMap, Map<String, String> headerMap) {
+        return postForm(url, paramsMap, connectTimeoutDefault, readTimeoutDefault, headerMap);
+    }
+
+    /**
+     * post请求,form表单,不能包含二进制数据
+     *
+     * @param url            请求的url
+     * @param paramsMap      form表单参数map
+     * @param connectTimeout 连接超时设置，毫秒
+     * @param readTimeout    读取超时设置，毫秒
+     * @param headerMap      form表单header
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent postForm(String url, Map<String, String> paramsMap, int connectTimeout,
+                                               int readTimeout, Map<String, String> headerMap) {
+        List<NameValuePair> nvps = new ArrayList<NameValuePair>();
+        if (Objects.nonNull(paramsMap)) {
+            Iterator<String> iterator = paramsMap.keySet().iterator();
+            while (iterator.hasNext()) {
+                String key = iterator.next();
+                Object value = paramsMap.get(key);
+                nvps.add(new BasicNameValuePair(key, String.valueOf(value)));
+            }
+        }
+        return postForm(url, nvps, connectTimeout, readTimeout, headerMap);
+    }
+
+    /**
+     * post请求,form表单,不能包含二进制数据
+     *
+     * @param url            请求的url
+     * @param nvps      form表单参数
+     * @param connectTimeout 连接超时设置，毫秒
+     * @param readTimeout    读取超时设置，毫秒
+     * @param headerMap      form表单header
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent postForm(String url, List<NameValuePair> nvps, int connectTimeout,
+                                               int readTimeout, Map<String, String> headerMap) {
+        HttpRequestBase request = null;
+        HttpResponseContent hrc = null;
+        HttpPost httpPost = new HttpPost(url);
+        // 设置header
+        if (headerMap != null) {
+            for (Entry<String, String> entry : headerMap.entrySet()) {
+                httpPost.addHeader(entry.getKey(), entry.getValue());
+            }
+        }
+        try {
+            httpPost.setEntity(new UrlEncodedFormEntity(nvps, charsetDefault));
+        } catch (UnsupportedEncodingException e) {
+            log.error(e);
+        }
+        request = httpPost;
+        hrc = executeHttpRequest(request, connectTimeout, readTimeout);
+        return hrc;
+    }
+
+    /**
+     * post请求，multipart,支持File，byte[]这两种二进制数据
+     *
+     * @param url       请求的url
+     * @param paramsMap 请求参数map
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent postMultipart(String url, Map<String, Object> paramsMap) {
+        return postMultipart(url, paramsMap, connectTimeoutDefault, readTimeoutDefault, null);
+    }
+
+    public static HttpResponseContent postMultipart(String url, Map<String, Object> paramsMap, Map<String, String> headerMap) {
+        return postMultipart(url, paramsMap, connectTimeoutDefault, readTimeoutDefault, headerMap);
+    }
+
+    /**
+     * post请求，multipart,支持File，byte[]这两种二进制数据
+     *
+     * @param url            请求的url
+     * @param paramsMap      请求参数map
+     * @param connectTimeout 连接超时设置，毫秒
+     * @param readTimeout    读取超时设置，毫秒
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    public static HttpResponseContent postMultipart(String url, Map<String, Object> paramsMap, int connectTimeout,
+                                                    int readTimeout, Map<String, String> headerMap) {
+        HttpRequestBase request = null;
+        HttpResponseContent hrc = null;
+        HttpPost httpPost = new HttpPost(url);
+        MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
+        multipartEntityBuilder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
+        Iterator<String> iterator = paramsMap.keySet().iterator();
+        while (iterator.hasNext()) {
+            String key = iterator.next();
+            Object value = paramsMap.get(key);
+            if (value instanceof File) {
+                multipartEntityBuilder.addBinaryBody(key, (File) value);
+            } else if (value instanceof byte[]) {
+                multipartEntityBuilder.addBinaryBody(key, (byte[]) value);
+            } else {
+                multipartEntityBuilder.addTextBody(key, String.valueOf(value),
+                        ContentType.create("text/plain", charsetDefault));
+            }
+        }
+        httpPost.setEntity(multipartEntityBuilder.build());
+        // 设置header
+        if (headerMap != null) {
+            for (Entry<String, String> entry : headerMap.entrySet()) {
+                httpPost.addHeader(entry.getKey(), entry.getValue());
+            }
+        }
+        request = httpPost;
+        hrc = executeHttpRequest(request, connectTimeout, readTimeout);
+        return hrc;
+    }
+
+    public static HttpResponseContent postRequestBody(String url, Object s, Map<String, String> headerMap) {
+        HttpRequestBase request = null;
+        HttpResponseContent hrc = null;
+        HttpPost httpPost = new HttpPost(url);
+
+        StringEntity stringEntity = new StringEntity((s instanceof String) ? (String) s : JSONObject.toJSONString(s), Consts.UTF_8);
+        stringEntity.setContentEncoding(Consts.UTF_8.name());
+        stringEntity.setContentType("application/json");
+        httpPost.setEntity(stringEntity);
+        // 设置header
+        if (headerMap != null) {
+            for (Entry<String, String> entry : headerMap.entrySet()) {
+                httpPost.addHeader(entry.getKey(), entry.getValue());
+            }
+        }
+        request = httpPost;
+        hrc = executeHttpRequest(request, connectTimeoutDefault, readTimeoutDefault);
+        return hrc;
+    }
+
+    public static HttpResponseContent patchRequestBody(String url, Object s, Map<String, String> headerMap) {
+        HttpRequestBase request = null;
+        HttpResponseContent hrc = null;
+        HttpPatch httpPost = new HttpPatch(url);
+
+        StringEntity stringEntity = new StringEntity((s instanceof String) ? (String) s : JSONObject.toJSONString(s), Consts.UTF_8);
+        stringEntity.setContentEncoding(Consts.UTF_8.name());
+        stringEntity.setContentType("application/json");
+        httpPost.setEntity(stringEntity);
+        // 设置header
+        if (headerMap != null) {
+            for (Entry<String, String> entry : headerMap.entrySet()) {
+                httpPost.addHeader(entry.getKey(), entry.getValue());
+            }
+        }
+        request = httpPost;
+        hrc = executeHttpRequest(request, connectTimeoutDefault, readTimeoutDefault);
+        return hrc;
+    }
+
+    public static HttpResponseContent deleteRequestBody(String url, Object s, HashMap<String, String> headerMap) {
+        HttpRequestBase request = null;
+        HttpResponseContent hrc = null;
+        HttpDeleteExpand httpDelete = new HttpDeleteExpand(url);
+
+        StringEntity stringEntity = new StringEntity(JSONObject.toJSONString(s), Consts.UTF_8);
+        stringEntity.setContentEncoding(Consts.UTF_8.name());
+        stringEntity.setContentType("application/json");
+        httpDelete.setEntity(stringEntity);
+        // 设置header
+        if (headerMap != null) {
+            for (Entry<String, String> entry : headerMap.entrySet()) {
+                httpDelete.addHeader(entry.getKey(), entry.getValue());
+            }
+        }
+        request = httpDelete;
+        hrc = executeHttpRequest(request, connectTimeoutDefault, readTimeoutDefault);
+        return hrc;
+    }
+
+    public static HttpResponseContent putRequestBody(String url, Object s, HashMap<String, String> headerMap) {
+        HttpRequestBase request = null;
+        HttpResponseContent hrc = null;
+        HttpPut httpPut = new HttpPut(url);
+
+        StringEntity stringEntity = new StringEntity(JSONObject.toJSONString(s), Consts.UTF_8);
+        stringEntity.setContentEncoding(Consts.UTF_8.name());
+        stringEntity.setContentType("application/json");
+        httpPut.setEntity(stringEntity);
+        // 设置header
+        if (headerMap != null) {
+            for (Entry<String, String> entry : headerMap.entrySet()) {
+                httpPut.addHeader(entry.getKey(), entry.getValue());
+            }
+        }
+        request = httpPut;
+        hrc = executeHttpRequest(request, connectTimeoutDefault, readTimeoutDefault);
+        return hrc;
+    }
+
+    /**
+     * 执行Http请求
+     *
+     * @param request
+     * @param connectTimeout
+     * @param readTimeout
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    private static HttpResponseContent executeHttpRequest(HttpRequestBase request, int connectTimeout,
+                                                          int readTimeout) {
+        CloseableHttpResponse response = null;
+        HttpResponseContent hrc = null;
+        try {
+            // 设置请求配置
+            RequestConfig.Builder configBuilder = RequestConfig.custom();
+            // 设置连接超时
+            configBuilder.setConnectTimeout(connectTimeout);
+            // 设置读取超时
+            configBuilder.setSocketTimeout(readTimeout);
+            // 设置从连接池获取连接实例的超时
+            configBuilder.setConnectionRequestTimeout(getConnectionTimeoutDefault);
+            RequestConfig requestConfig = configBuilder.build();
+            request.setConfig(requestConfig);
+            log.debug("开始执行Http请求, uri:" + request.getURI());
+            response = client.execute(request);
+            hrc = getHttpResponseContent(response);
+            return hrc;
+        } catch (Exception e) {
+            log.error("执行Http请求异常, uri:" + request.getURI(), e);
+        } finally {
+            close(request, response);
+        }
+        return hrc;
+
+    }
+
+    /**
+     * 封装HTTP响应报文
+     *
+     * @param response
+     * @return
+     */
+    private static HttpResponseContent getHttpResponseContent(CloseableHttpResponse response) {
+        // 获取响应实体
+        HttpEntity entity = response.getEntity();
+        if (entity == null) {
+            return null;
+        }
+        HttpResponseContent hrc = new HttpResponseContent();
+        hrc.setHeaders(response.getAllHeaders());
+        hrc.setStatusCode(response.getStatusLine().getStatusCode());
+        ContentType contentType = ContentType.getOrDefault(entity);
+        hrc.setMimeType(contentType.getMimeType());
+        if (contentType.getCharset() != null) {
+            hrc.setCharsetName(contentType.getCharset().name());
+        }
+        try {
+            hrc.setContentBytes(EntityUtils.toByteArray(entity));
+        } catch (IOException e) {
+            log.error("封装HTTP响应报文异常", e);
+        }
+        return hrc;
+
+    }
+
+    /**
+     * 执行Http请求
+     *
+     * @param request
+     * @param connectTimeout
+     * @param readTimeout
+     * @return HttpResponseContent对象，如果http请求出现异常，返回null
+     */
+    private static HttpResponseContent executeHeadHttpRequest(HttpRequestBase request, int connectTimeout,
+                                                          int readTimeout) {
+        CloseableHttpResponse response = null;
+        HttpResponseContent hrc = null;
+        try {
+            // 设置请求配置
+            RequestConfig.Builder configBuilder = RequestConfig.custom();
+            // 设置连接超时
+            configBuilder.setConnectTimeout(connectTimeout);
+            // 设置读取超时
+            configBuilder.setSocketTimeout(readTimeout);
+            // 设置从连接池获取连接实例的超时
+            configBuilder.setConnectionRequestTimeout(getConnectionTimeoutDefault);
+            RequestConfig requestConfig = configBuilder.build();
+            request.setConfig(requestConfig);
+            log.debug("开始执行Http请求, uri:" + request.getURI());
+            response = client.execute(request);
+            hrc = getHeadHttpResponseContent(response);
+            return hrc;
+        } catch (Exception e) {
+            log.error("执行Http请求异常, uri:" + request.getURI(), e);
+        } finally {
+            close(request, response);
+        }
+        return hrc;
+
+    }
+
+    /**
+     * 封装HTTP响应报文
+     *
+     * @param response
+     * @return
+     */
+    private static HttpResponseContent getHeadHttpResponseContent(CloseableHttpResponse response) {
+        HttpResponseContent hrc = new HttpResponseContent();
+        hrc.setHeaders(response.getAllHeaders());
+        hrc.setStatusCode(response.getStatusLine().getStatusCode());
+        HttpEntity entity = response.getEntity();
+        if (entity != null) {
+            ContentType contentType = ContentType.getOrDefault(entity);
+            hrc.setMimeType(contentType.getMimeType());
+            if (contentType.getCharset() != null) {
+                hrc.setCharsetName(contentType.getCharset().name());
+            }
+            try {
+                hrc.setContentBytes(EntityUtils.toByteArray(entity));
+            } catch (IOException e) {
+                log.error("封装HTTP响应报文异常", e);
+            }
+        }
+
+        return hrc;
+
+    }
+
+    /**
+     * 关闭资源
+     *
+     * @param request
+     * @param response
+     */
+    private static void close(HttpRequestBase request, CloseableHttpResponse response) {
+        try {
+            if (request != null)
+                request.releaseConnection();
+            if (response != null)
+                response.close();
+        } catch (Exception e) {
+            log.error("关闭资源异常", e);
+        }
+    }
+
+    /**
+     * url编码
+     *
+     * @param url
+     * @param charset
+     * @return
+     */
+    public static String encodeURL(String url, String charset) {
+        if (url == null || charset == null) {
+            return null;
+        }
+        int p = url.indexOf("?");
+        if (p < 0) {
+            return url;
+        }
+        StringBuilder sb = new StringBuilder();
+        String preStr = url.substring(0, p + 1);
+        sb.append(preStr);
+        String queryStr = url.substring(p + 1, url.length());
+        String[] array = queryStr.split("&");
+        for (int i = 0; i < array.length; i++) {
+            String str = array[i];
+            int pp = str.indexOf("=");
+            if (pp > -1) {
+                sb.append(str.substring(0, pp + 1));
+                try {
+                    sb.append(URLEncoder.encode(str.substring(pp + 1, str.length()), charset));
+                } catch (UnsupportedEncodingException e) {
+                    e.printStackTrace();
+                }
+                if (i < array.length - 1) {
+                    sb.append("&");
+                }
+            }
+        }
+        return sb.toString();
+    }
+
+}

src/main/java/com/tzld/ffmpeg/util/http/HttpDeleteExpand.java

@@ -0,0 +1,24 @@
+package com.tzld.ffmpeg.util.http;
+
+import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
+
+import java.net.URI;
+
+public class HttpDeleteExpand extends HttpEntityEnclosingRequestBase {
+    public static final String METHOD_NAME = "DELETE";
+
+    public HttpDeleteExpand() {
+    }
+
+    public HttpDeleteExpand(URI uri) {
+        this.setURI(uri);
+    }
+
+    public HttpDeleteExpand(String uri) {
+        this.setURI(URI.create(uri));
+    }
+
+    public String getMethod() {
+        return "DELETE";
+    }
+}

src/main/java/com/tzld/ffmpeg/util/http/HttpResponseContent.java

@@ -0,0 +1,102 @@
+package com.tzld.ffmpeg.util.http;
+
+import org.apache.http.Header;
+
+import java.io.UnsupportedEncodingException;
+
+/**
+ * HTTP请求响应报文封装类
+ * 
+ * @author liuzhiheng
+ * @since 1.0
+ * @date 2017-4-7 下午12:14:16
+ */
+public class HttpResponseContent {
+
+	private int statusCode; // 响应状态码
+	private String mimeType; // mime类型
+	private String charsetName; // 字符集
+	private byte[] contentBytes; // 响应报文主体内容的二进制数据
+	private Header[] headers; // 响应头
+
+	/**
+	 * 获取响应报文主体内容，字符串,使用响应报文中的字符集编码
+	 * 
+	 * @return
+	 */
+	public String getBodyContent() {
+		return this.getBodyContent(charsetName);
+	}
+
+	/**
+	 * 获取响应报文主体内容，字符串
+	 * 
+	 * @param charsetName
+	 *            指定的字符编码
+	 * @return
+	 */
+	public String getBodyContent(String charsetName) {
+		String str = null;
+		if (charsetName == null) {
+			charsetName = "UTF-8";
+		}
+		try {
+			str = new String(contentBytes, charsetName);
+		} catch (UnsupportedEncodingException e) {
+			// 忽略异常
+			e.printStackTrace();
+		}
+		return str;
+	}
+
+	public boolean isSuccessful(){
+		return statusCode == 200;
+	}
+
+	public int getStatusCode() {
+		return statusCode;
+	}
+
+	public void setStatusCode(int statusCode) {
+		this.statusCode = statusCode;
+	}
+
+	public String getMimeType() {
+		return mimeType;
+	}
+
+	public void setMimeType(String mimeType) {
+		this.mimeType = mimeType;
+	}
+
+	public String getCharsetName() {
+		return charsetName;
+	}
+
+	public void setCharsetName(String charsetName) {
+		this.charsetName = charsetName;
+	}
+
+	public byte[] getContentBytes() {
+		return contentBytes;
+	}
+
+	public void setContentBytes(byte[] contentBytes) {
+		this.contentBytes = contentBytes;
+	}
+
+	public Header[] getHeaders() {
+		return headers;
+	}
+
+	public void setHeaders(Header[] headers) {
+		this.headers = headers;
+	}
+
+	@Override
+	public String toString() {
+		return "HttpResponseContent [statusCode=" + statusCode + ", mimeType=" + mimeType + ", charsetName=" + charsetName
+				+ ", bodyContent=" + getBodyContent() + "]";
+	}
+
+}

src/main/java/com/tzld/ffmpeg/util/http/HttpTest.java

@@ -0,0 +1,21 @@
+package com.tzld.ffmpeg.util.http;
+
+import org.apache.http.Header;
+
+public class HttpTest {
+
+    public static void main(String[] args) throws Exception {
+//        String url = "https://video-cn.oceanengine.com/a62b02095a3aea864db83d224b96b5e6/673aebf5/tos-cn-v-29cc83/ocEXva9SIAOfZEc6QnOgbJEfCBF1z3ODtUK82y?a=512179&ch=0&cr=0&dr=3&cd=0%7C0%7C0%7C0&br=5729&bt=5729&cs=0&ds=12&ft=J9ThAGkHH_Myq8ZNYwDXe2NvjTQ&mime_type=video_mp4&qs=0&rc=NXZpTGRTaFBnKWxncmd5aHFsc3IxZGY4NDo3aGRoaTc7NTNmZzg7QGlqbXk2czlyeWd2NjM0aTwzQFNsa3ZpcUQ6amtqXmJmK2BeaWpgYTojYC41MzQ2LTY0MTNeMzU1L2EjMXNiLjJkNG5xYC0tZC8vc3M%3D&btag=c0000200018000&dy_q=1731911104&feature_id=f0150a16a324336cda5d6dd0b69ed299&l=20241118142504AF2E4D16450DD945DCFF&ply_type=3&policy=eyJ2bSI6MywidWlkIjoiMTg1NDIxNTEyNTQ3ODUyNCJ9&download=true";
+//
+//        HttpResponseContent hrc = HttpClientUtils.get(url);
+//        System.out.println(hrc.getStatusCode());
+//
+//        FileUtils.saveFileContent("/Users/liuzhiheng/Downloads/123.mp4", hrc.getContentBytes());
+        String url = "https://www.douyin.com/aweme/v1/play/?video_id=v0200fg10000cv41l0nog65stf3tpfu0&ratio=1080p&line=0";
+        HttpResponseContent hrc = HttpClientUtils.head(url);
+        for (Header header : hrc.getHeaders()) {
+            System.out.println(header.getName() + ":" + header.getValue());
+        }
+        System.out.println(hrc.getStatusCode());
+    }
+}

src/main/resources/application-dev.yml

@@ -0,0 +1,56 @@
+server:
+  port: 8080
+
+spring:
+  datasource:
+    ffmpeg:
+      driver-class-name: com.mysql.jdbc.Driver
+      jdbc-url: jdbc:mysql://rm-bp13g3ra2f59q49xs.mysql.rds.aliyuncs.com:3306/ai_supply?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false
+      username: wqsd
+      password: wqsd@2025
+      type: com.zaxxer.hikari.HikariDataSource
+      hikari:
+        minimum-idle: 10
+        maximum-pool-size: 20
+        connection-test-query: SELECT 1
+  redis:
+    host: r-bp1ps6my7lzg8rdhwxpd.redis.rds.aliyuncs.com
+    port: 6379
+    password: Wqsd@2019
+
+xxl:
+  job:
+    admin:
+      addresses: http://xxl-job-test-internal.piaoquantv.com/xxl-job-admin
+
+aliyun:
+  log:
+    endpoint: cn-hangzhou.log.aliyuncs.com
+    accessKeyId: LTAIP6x1l3DXfSxm
+    accessKeySecret: KbTaM9ars4OX3PMS6Xm7rtxGr1FLon
+    project: ffmpeg-server-test
+    requestLogstore: request-log
+    logstore:
+      info: info-log
+      error: error-log
+
+apollo:
+  meta: http://devapolloconfig-internal.piaoquantv.com
+
+feign:
+  client:
+    config:
+      default:  # 默认 Feign 客户端配置
+        logger-level: NONE  # 日志级别（NONE/BASE/HEADERS/FULL）
+        connect-timeout: 20000  # 连接超时时间（毫秒）
+        read-timeout: 20000  # 读取超时时间（毫秒）
+
+eureka:
+  client:
+    service-url:  # Eureka 服务注册中心地址
+      defaultZone: http://deveureka-internal.piaoquantv.com/eureka/  # 注册中心 URL
+
+danger:
+  face:
+    recognize:
+      host: http://47.111.230.160:5000

src/main/resources/application-prod.yml

@@ -0,0 +1,52 @@
+server:
+  port: 8080
+
+spring:
+  datasource:
+    ffmpeg:
+      driver-class-name: com.mysql.jdbc.Driver
+      jdbc-url: jdbc:mysql://rm-bp13g3ra2f59q49xs.mysql.rds.aliyuncs.com:3306/ai_supply?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false
+      username: wqsd
+      password: wqsd@2025
+      type: com.zaxxer.hikari.HikariDataSource
+      hikari:
+        minimum-idle: 10
+        maximum-pool-size: 20
+        connection-test-query: SELECT 1
+  redis:
+    host: r-bp1rbmomeunfo3b3vppd.redis.rds.aliyuncs.com
+    port: 6379
+    password: wqsd@2025
+
+xxl:
+  job:
+    admin:
+      addresses: http://xxl-job-internal.piaoquantv.com/xxl-job-admin
+
+aliyun:
+  log:
+    endpoint: cn-hangzhou.log.aliyuncs.com
+    accessKeyId: LTAIP6x1l3DXfSxm
+    accessKeySecret: KbTaM9ars4OX3PMS6Xm7rtxGr1FLon
+    project: ffmpeg-server-prod
+    requestLogstore: request-log
+    logstore:
+      info: info-log
+      error: error-log
+
+apollo:
+  meta: http://apolloconfig-internal.piaoquantv.com
+
+feign:
+  client:
+    config:
+      default:  # 默认 Feign 客户端配置
+        logger-level: NONE  # 日志级别（NONE/BASE/HEADERS/FULL）
+        connect-timeout: 20000  # 连接超时时间（毫秒）
+        read-timeout: 20000  # 读取超时时间（毫秒）
+
+eureka:
+  client:
+    service-url:  # Eureka 服务注册中心地址
+      defaultZone: http://eureka-internal.piaoquantv.com/eureka/  # 注册中心 URL
+

src/main/resources/application-test.yml

@@ -0,0 +1,51 @@
+server:
+  port: 8080
+
+spring:
+  datasource:
+    ffmpeg:
+      driver-class-name: com.mysql.jdbc.Driver
+      jdbc-url: jdbc:mysql://rm-bp13g3ra2f59q49xs.mysql.rds.aliyuncs.com:3306/ai_supply?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false
+      username: wqsd
+      password: wqsd@2025
+      type: com.zaxxer.hikari.HikariDataSource
+      hikari:
+        minimum-idle: 10
+        maximum-pool-size: 20
+        connection-test-query: SELECT 1
+  redis:
+    host: r-bp1ps6my7lzg8rdhwxpd.redis.rds.aliyuncs.com
+    port: 6379
+    password: Wqsd@2019
+
+xxl:
+  job:
+    admin:
+      addresses: http://xxl-job-test-internal.piaoquantv.com/xxl-job-admin
+
+aliyun:
+  log:
+    endpoint: cn-hangzhou.log.aliyuncs.com
+    accessKeyId: LTAIP6x1l3DXfSxm
+    accessKeySecret: KbTaM9ars4OX3PMS6Xm7rtxGr1FLon
+    project: ffmpeg-server-test
+    requestLogstore: request-log
+    logstore:
+      info: info-log
+      error: error-log
+
+apollo:
+  meta: http://testapolloconfig-internal.piaoquantv.com
+
+feign:
+  client:
+    config:
+      default:  # 默认 Feign 客户端配置
+        logger-level: NONE  # 日志级别（NONE/BASE/HEADERS/FULL）
+        connect-timeout: 20000  # 连接超时时间（毫秒）
+        read-timeout: 20000  # 读取超时时间（毫秒）
+
+eureka:
+  client:
+    service-url:  # Eureka 服务注册中心地址
+      defaultZone: http://testeureka-internal.piaoquantv.com/eureka/  # 注册中心 URL

src/main/resources/application.yml

@@ -0,0 +1,100 @@
+spring:
+  profiles:
+    active: dev
+  application:
+    name: ffmpeg-server
+
+server:
+  tomcat:
+    threads:
+      max: 1000
+    uri-encoding: UTF-8
+    accept-count: 1000
+    connection-timeout: 30000
+  servlet:
+    context-path: /
+    session:
+      timeout: 60
+pagehelper:
+  helper-dialect: mysql
+
+mybatis:
+  mapper-locations: classpath:mapper/**/*.xml
+  configuration:
+    use-generated-keys: true
+    map-underscore-to-camel-case: true
+    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl  # 直接输出到控制台（简单调试用）
+
+app:
+  id: ffmpeg-server  # 应用标识
+  build:
+    time: @mavenBuildTime@
+
+xxl:
+  job:
+    accessToken:
+    executor:
+      appname: ${spring.application.name}
+      address:
+      ip:
+      port: 9999
+      logpath: /datalog/weblog/xxl-job/jobhandler
+      logretentiondays: 7
+
+apollo:
+  bootstrap:
+    enabled: true  # 启用 Apollo 配置预加载
+    namespaces: application  # 指定加载的命名空间
+  cacheDir: /datalog/apollo-cache-dir  # Apollo 本地缓存目录
+
+eureka:
+  instance:
+    prefer-ip-address: true  # 优先使用 IP 地址注册
+    instance-id: ${spring.cloud.client.ip-address}:${spring.application.name}:${server.port}  # 实例 ID 格式
+    lease-renewal-interval-in-seconds: 30  # 心跳续约间隔（秒）
+    lease-expiration-duration-in-seconds: 90  # 心跳过期时间（秒）
+  client:
+    registry-fetch-interval-seconds: 5  # 拉取服务注册列表间隔（秒）
+
+logging:
+  level:
+    # 替换为你的 Mapper 接口所在包路径（根据错误日志中的包名调整）
+    com.tzld.ffmpeg.dao.mapper.ffmpeg.spider: DEBUG  # 输出该包下所有 Mapper 的 SQL 日志
+    # 可选：HikariCP 连接池日志（调试连接问题时开启）
+    com.zaxxer.hikari: INFO  # 连接池基本信息（避免 DEBUG 级别日志过多）
+
+oss:
+  ffmpeg:
+    accessKey: LTAIP6x1l3DXfSxm
+    secretKey: KbTaM9ars4OX3PMS6Xm7rtxGr1FLon
+    ossEndPoint: oss-cn-hangzhou.aliyuncs.com
+    videoEndPoint: slicevideo.yishihui.com
+    expiration: 3600
+    projectName: ffmpeg
+    cdnDomain: http://rescdn.yishihui.com/
+    imgDomain: http://rescdn.yishihui.com/
+    videoDomain: http://rescdn.yishihui.com/
+    lvvideoDomain: https://lvupload.piaoquantv.com/
+    pubBucket: public:art-pubbucket,publicVideo:art-pubbucket
+    priBucket: private:art-pribucket,privateVideo:art-privideo,privateVideoIn:art-privideo-in
+    priEndPoint: pricdn.yishihui.com
+    needPress: true
+    internal:
+      endPoint: oss-cn-hangzhou.aliyuncs.com
+  longvideo:
+    video:
+      sts:
+        endpoint: sts.cn-hangzhou.aliyuncs.com
+        accessKeyId: LTAIfZYdxeQpq3YI
+        accessKeySecret: 1yISVWe5Gws2VAdTMc9XWIHpjPd7ja
+        roleArn: acs:ram::1894469520484605:role/oss-sts
+        roleSessionName: session-name
+  accelerate:
+    upload:
+      domain: https://ossaccelerateupload.piaoquantv.com/
+  video:
+    bucket: art-pubbucket
+
+cdn:
+  upload:
+    domain: https://weappupload.piaoquantv.com/

src/main/resources/generator/mybatis-ffmpeg-generator-config.xml

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE generatorConfiguration
+        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
+        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
+<!-- 配置生成器 -->
+<generatorConfiguration>
+    <context id="mysql" defaultModelType="flat">
+        <property name="autoDelimitKeywords" value="true"/>
+        <!-- 生成的Java文件的编码 -->
+        <property name="javaFileEncoding" value="UTF-8"/>
+        <!-- 格式化java代码 -->
+        <property name="javaFormatter" value="org.mybatis.generator.api.dom.DefaultJavaFormatter"/>
+        <!-- 格式化XML代码 -->
+        <property name="xmlFormatter" value="org.mybatis.generator.api.dom.DefaultXmlFormatter"/>
+        <!-- beginningDelimiter和endingDelimiter：指明数据库的用于标记数据库对象名的符号，比如ORACLE就是双引号，MYSQL默认是`反引号； -->
+        <property name="beginningDelimiter" value="`"/>
+        <property name="endingDelimiter" value="`"/>
+
+        <plugin type="org.mybatis.generator.plugins.ToStringPlugin" />
+        <plugin type="org.mybatis.generator.plugins.UnmergeableXmlMappersPlugin" />
+
+        <commentGenerator>
+            <property name="addRemarkComments" value="true"/>
+        </commentGenerator>
+
+        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
+                        connectionURL="jdbc:mysql://rm-bp13g3ra2f59q49xs.mysql.rds.aliyuncs.com:3306/ai_supply?useUnicode=true&amp;characterEncoding=utf-8&amp;zeroDateTimeBehavior=convertToNull&amp;useSSL=false"
+                        userId="wqsd" password="wqsd@2025">
+        </jdbcConnection>
+
+        <javaTypeResolver type="org.mybatis.generator.internal.types.JavaTypeResolverDefaultImpl">
+            <property name="forceBigDecimals" value="false"/>
+        </javaTypeResolver>
+
+        <javaModelGenerator targetPackage="com.tzld.ffmpeg.model.po.ffmpeg.spider" targetProject="core/src/main/java">
+            <property name="constructorBased" value="false"/>
+            <property name="enableSubPackages" value="true"/>
+            <property name="immutable" value="false"/>
+        </javaModelGenerator>
+
+        <sqlMapGenerator targetPackage="mapper.ffmpeg.spider" targetProject="core/src/main/resources">
+            <property name="enableSubPackages" value="true"/>
+        </sqlMapGenerator>
+
+        <javaClientGenerator targetPackage="com.tzld.ffmpeg.dao.mapper.ffmpeg" type="XMLMAPPER" targetProject="core/src/main/java">
+            <property name="enableSubPackages" value="true"/>
+        </javaClientGenerator>
+
+        <table tableName="produce_video_material" domainObjectName="" alias=""/>
+    </context>
+
+</generatorConfiguration>

src/main/resources/logback-spring.xml

@@ -0,0 +1,166 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 -->
+<!-- scan:当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true -->
+<!-- scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
+<!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
+<configuration scan="true" scanPeriod="10 seconds">
+    <!--<include resource="org/springframework/boot/logging/logback/base.xml"/>-->
+
+    <contextName>logback</contextName>
+    <!-- name的值是变量的名称，value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义变量后，可以使“${}”来使用变量。 -->
+    <!-- <property name="LOG_PATH"  value="${logging.file.path}" />-->
+
+    <springProperty name="LOG_PATH" source="logging.file.path"/>
+    <springProperty name="ALIYUN_LOG_ENDPOINT" source="aliyun.log.endpoint"/>
+    <springProperty name="ALIYUN_LOG_ACCESSKEYID" source="aliyun.log.accessKeyId"/>
+    <springProperty name="ALIYUN_LOG_ACCESSKEYSECRET" source="aliyun.log.accessKeySecret"/>
+    <springProperty name="ALIYUN_LOG_PROJECT" source="aliyun.log.project"/>
+    <springProperty name="ALIYUN_LOG_LOGSTORE_INFO" source="aliyun.log.logstore.info"/>
+    <springProperty name="ALIYUN_LOG_LOGSTORE_ERROR" source="aliyun.log.logstore.error"/>
+
+    <!-- 彩色日志 -->
+    <!-- 彩色日志依赖的渲染类 -->
+    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter"/>
+    <conversionRule conversionWord="wex"
+                    converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>
+    <conversionRule conversionWord="wEx"
+                    converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter"/>
+    <!-- 彩色日志格式 -->
+    <property name="CONSOLE_LOG_PATTERN"
+              value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr([%X{logTraceId}]){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>
+    <!--<property name="CONSOLE_LOG_PATTERN"-->
+    <!--          value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr([%X{√logTraceId}]){magenta} %clr(-&#45;&#45;){faint} %clr([%15.15t]){faint} %clr(at %class.%method){cyan} \\(%file:%line\\) %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>-->
+
+    <!--输出到控制台-->
+    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
+        <!--此日志appender是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息-->
+        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+            <level>debug</level>
+        </filter>
+        <encoder>
+            <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
+            <!-- 设置字符集 -->
+            <charset>UTF-8</charset>
+        </encoder>
+    </appender>
+
+
+    <appender name="ALIYUN_LOG_INFO" class="com.tzld.ffmpeg.common.LoghubAppender">
+        <endpoint>${ALIYUN_LOG_ENDPOINT}</endpoint>
+        <accessKeyId>${ALIYUN_LOG_ACCESSKEYID}</accessKeyId>
+        <accessKeySecret>${ALIYUN_LOG_ACCESSKEYSECRET}</accessKeySecret>
+        <project>${ALIYUN_LOG_PROJECT}</project>
+        <logStore>${ALIYUN_LOG_LOGSTORE_INFO}</logStore>
+
+        <totalSizeInBytes>104857600</totalSizeInBytes>
+        <maxBlockMs>0</maxBlockMs>
+        <ioThreadCount>8</ioThreadCount>
+        <batchSizeThresholdInBytes>524288</batchSizeThresholdInBytes>
+        <batchCountThreshold>4096</batchCountThreshold>
+        <lingerMs>2000</lingerMs>
+        <retries>10</retries>
+        <baseRetryBackoffMs>100</baseRetryBackoffMs>
+        <maxRetryBackoffMs>50000</maxRetryBackoffMs>
+
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level [%X{logTraceId}] %logger{50} [%L] - %msg%n</pattern>
+            <charset>UTF-8</charset>
+        </encoder>
+
+        <timeFormat>yyyy-MM-dd'T'HH:mmZ</timeFormat>
+        <timeZone>Asia/Shanghai</timeZone>
+
+        <filter class="ch.qos.logback.classic.filter.LevelFilter">
+            <level>INFO</level>
+        </filter>
+
+        <mdcFields>logTraceId</mdcFields>
+    </appender>
+
+    <appender name="ALIYUN_LOG_ERROR" class="com.tzld.ffmpeg.common.LoghubAppender">
+        <endpoint>${ALIYUN_LOG_ENDPOINT}</endpoint>
+        <accessKeyId>${ALIYUN_LOG_ACCESSKEYID}</accessKeyId>
+        <accessKeySecret>${ALIYUN_LOG_ACCESSKEYSECRET}</accessKeySecret>
+        <project>${ALIYUN_LOG_PROJECT}</project>
+        <logStore>${ALIYUN_LOG_LOGSTORE_ERROR}</logStore>
+
+        <totalSizeInBytes>104857600</totalSizeInBytes>
+        <maxBlockMs>0</maxBlockMs>
+        <ioThreadCount>8</ioThreadCount>
+        <batchSizeThresholdInBytes>524288</batchSizeThresholdInBytes>
+        <batchCountThreshold>4096</batchCountThreshold>
+        <lingerMs>2000</lingerMs>
+        <retries>10</retries>
+        <baseRetryBackoffMs>100</baseRetryBackoffMs>
+        <maxRetryBackoffMs>50000</maxRetryBackoffMs>
+
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level [%X{logTraceId}] %logger{50} [%L] - %msg%n</pattern>
+            <charset>UTF-8</charset>
+        </encoder>
+
+        <timeFormat>yyyy-MM-dd'T'HH:mmZ</timeFormat>
+        <timeZone>Asia/Shanghai</timeZone>
+
+        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+            <level>ERROR</level>
+        </filter>
+
+        <mdcFields>logTraceId</mdcFields>
+    </appender>
+
+    <!--
+        <logger>用来设置某一个包或者具体的某一个类的日志打印级别、以及指定<appender>。
+        <logger>仅有一个name属性，一个可选的level和一个可选的addtivity属性。
+        name:用来指定受此logger约束的某一个包或者具体的某一个类。
+        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
+              还有一个特俗值INHERITED或者同义词NULL，代表强制执行上级的级别。
+              如果未设置此属性，那么当前logger将会继承上级的级别。
+        addtivity:是否向上级logger传递打印信息。默认是true。
+    -->
+    <!--<logger name="org.springframework.web" level="info"/>-->
+    <!--<logger name="org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor" level="INFO"/>-->
+
+    <!--
+        使用mybatis的时候，sql语句是debug下才会打印，而这里我们只配置了info，所以想要查看sql语句的话，有以下两种操作：
+        第一种把<root level="info">改成<root level="DEBUG">这样就会打印sql，不过这样日志那边会出现很多其他消息
+        第二种就是单独给dao下目录配置 <logger> 指定 level 属性为 debug，这样配置sql语句会打印，其他还是正常info级别：
+     -->
+
+    <!--<springProfile name="dev">-->
+    <!--    <logger name="com.tzld.piaoquan.ad" level="debug"/>-->
+    <!--    <logger name="com.ctrip.framework.apollo.internals.RemoteConfigLongPollService" level="error"/>-->
+    <!--</springProfile>-->
+    <!--<springProfile name="test">-->
+    <!--    <logger name="com.tzld.piaoquan.ad" level="info"/>-->
+    <!--</springProfile>-->
+    <!--<springProfile name="pre">-->
+    <!--    <logger name="com.tzld.piaoquan.ad" level="info"/>-->
+    <!--</springProfile>-->
+    <!--<springProfile name="stress">-->
+    <!--    <logger name="com.tzld.piaoquan.ad" level="info"/>-->
+    <!--</springProfile>-->
+    <!--<springProfile name="prod">-->
+    <!--    <logger name="com.tzld.piaoquan.ad" level="info"/>-->
+    <!--</springProfile>-->
+    <!--<logger name="com.netflix.discovery.shared.resolver.aws.ConfigClusterResolver" level="warn"/>-->
+
+    <!-- 可用来获取 StatusManager 中的状态 -->
+    <!--<statusListener class="ch.qos.logback.core.status.OnConsoleStatusListener"/>-->
+    <!-- 解决 aliyun loghub debug模式下循环发送的问题 -->
+    <logger name="org.apache.http.impl.conn.Wire" level="WARN"/>
+    <!--aliyun loghub 为了防止进程退出时，内存中的数据丢失，请加上此选项-->
+    <shutdownHook class="ch.qos.logback.core.hook.DelayingShutdownHook"/>
+
+    <!--
+        root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性
+        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
+        不能设置为INHERITED或者同义词NULL。默认是DEBUG
+        可以包含零个或多个元素，标识这个appender将会添加到这个logger。
+    -->
+    <root level="info">
+        <appender-ref ref="CONSOLE"/>
+        <appender-ref ref="ALIYUN_LOG_INFO"/>
+        <appender-ref ref="ALIYUN_LOG_ERROR"/>
+    </root>
+</configuration>

src/main/resources/mapper/ffmpeg/ext/SpiderMapperExt.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.tzld.ffmpeg.dao.mapper.ffmpeg.ext.SpiderMapperExt">
+
+</mapper>