package com.tcm.training.admin.upload;
|
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.StringUtils;
|
|
import java.io.ByteArrayOutputStream;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.net.HttpURLConnection;
|
import java.net.URL;
|
import java.nio.charset.StandardCharsets;
|
|
/**
|
* 远程视频时长识别服务。
|
*/
|
@Service
|
public class RemoteVideoDurationService {
|
|
private static final int CONNECT_TIMEOUT_MILLIS = 5000;
|
private static final int READ_TIMEOUT_MILLIS = 20000;
|
private static final int INITIAL_TAIL_PROBE_BYTES = 256 * 1024;
|
private static final int RANGE_CHUNK_BYTES = 2 * 1024 * 1024;
|
private static final int MAX_MOOV_BOX_BYTES = 64 * 1024 * 1024;
|
private static final int MAX_RANGE_DETECT_BYTES = 32 * 1024 * 1024;
|
private static final int MAX_DOWNLOAD_BYTES = 200 * 1024 * 1024;
|
private static final String TYPE_MOOV = "moov";
|
private static final String TYPE_MVHD = "mvhd";
|
|
/**
|
* 识别远程视频时长。
|
*/
|
public VideoDurationDetectVO detectDuration(String videoUrl) {
|
String normalizedUrl = normalizeVideoUrl(videoUrl);
|
Long contentLength = fetchContentLength(normalizedUrl);
|
Integer moovRangeDetectedDuration = detectDurationByMoovRange(normalizedUrl, contentLength);
|
if (moovRangeDetectedDuration != null) {
|
return new VideoDurationDetectVO(moovRangeDetectedDuration);
|
}
|
Integer windowRangeDetectedDuration = detectDurationByRange(normalizedUrl, contentLength);
|
if (windowRangeDetectedDuration != null) {
|
return new VideoDurationDetectVO(windowRangeDetectedDuration);
|
}
|
byte[] videoBytes = downloadVideoBytes(normalizedUrl);
|
return new VideoDurationDetectVO(parseDurationSeconds(videoBytes));
|
}
|
|
/**
|
* 通过尾部分段定位 moov 盒子并按最小范围拉取目标字节。
|
*/
|
private Integer detectDurationByMoovRange(String videoUrl, Long contentLength) {
|
if (contentLength == null || contentLength <= 0L) {
|
return null;
|
}
|
long tailProbeLength = Math.min(INITIAL_TAIL_PROBE_BYTES, contentLength);
|
long tailStart = Math.max(0L, contentLength - tailProbeLength);
|
try {
|
byte[] tailProbeBytes = downloadRangeBytes(videoUrl, tailStart, contentLength - 1L);
|
ByteRange moovRange = resolveMoovRangeFromTailChunk(tailProbeBytes, tailStart, contentLength);
|
if (moovRange == null) {
|
return null;
|
}
|
long moovSize = moovRange.end - moovRange.start + 1L;
|
if (moovSize <= 0L || moovSize > MAX_MOOV_BOX_BYTES) {
|
return null;
|
}
|
|
byte[] moovBytes = extractBytesIfInsideChunk(tailProbeBytes, tailStart, moovRange);
|
if (moovBytes == null) {
|
moovBytes = downloadRangeBytes(videoUrl, moovRange.start, moovRange.end);
|
}
|
int durationSeconds = parseDurationSecondsSafely(moovBytes);
|
return durationSeconds > 0 ? durationSeconds : null;
|
} catch (Exception ex) {
|
return null;
|
}
|
}
|
|
/**
|
* 通过 HTTP Range 先读取文件头尾，尽量避免整文件下载。
|
*/
|
private Integer detectDurationByRange(String videoUrl, Long contentLength) {
|
try {
|
if (contentLength == null || contentLength <= 0L) {
|
return null;
|
}
|
long detectLimit = Math.min(contentLength, MAX_RANGE_DETECT_BYTES);
|
if (detectLimit <= 0L) {
|
return null;
|
}
|
|
long headLength = Math.min(RANGE_CHUNK_BYTES, detectLimit);
|
byte[] headBytes = downloadRangeBytes(videoUrl, 0L, headLength - 1L);
|
int headDuration = parseDurationSecondsSafely(headBytes);
|
if (headDuration > 0) {
|
return headDuration;
|
}
|
|
long tailWindowLength = Math.min(RANGE_CHUNK_BYTES, detectLimit);
|
while (tailWindowLength <= detectLimit) {
|
long start = Math.max(0L, contentLength - tailWindowLength);
|
byte[] tailBytes = downloadRangeBytes(videoUrl, start, contentLength - 1L);
|
int tailDuration = parseDurationSecondsFromTailChunk(tailBytes);
|
if (tailDuration > 0) {
|
return tailDuration;
|
}
|
if (tailWindowLength == detectLimit) {
|
break;
|
}
|
tailWindowLength = Math.min(detectLimit, tailWindowLength + RANGE_CHUNK_BYTES);
|
}
|
return null;
|
} catch (Exception ex) {
|
return null;
|
}
|
}
|
|
/**
|
* 归一化并校验远程视频地址。
|
*/
|
private String normalizeVideoUrl(String videoUrl) {
|
if (!StringUtils.hasText(videoUrl)) {
|
throw new IllegalArgumentException("请输入视频地址");
|
}
|
String normalizedUrl = videoUrl.trim();
|
try {
|
URL url = new URL(normalizedUrl);
|
String protocol = url.getProtocol();
|
if (!"http".equalsIgnoreCase(protocol) && !"https".equalsIgnoreCase(protocol)) {
|
throw new IllegalArgumentException("视频地址仅支持 HTTP 或 HTTPS");
|
}
|
return normalizedUrl;
|
} catch (IllegalArgumentException ex) {
|
throw ex;
|
} catch (Exception ex) {
|
throw new IllegalArgumentException("视频地址格式不正确");
|
}
|
}
|
|
/**
|
* 通过 HEAD 请求探测资源大小。
|
*/
|
private Long fetchContentLength(String videoUrl) {
|
HttpURLConnection connection = null;
|
try {
|
connection = (HttpURLConnection) new URL(videoUrl).openConnection();
|
connection.setRequestMethod("HEAD");
|
applyConnectionConfig(connection);
|
int responseCode = connection.getResponseCode();
|
if (responseCode < 200 || responseCode >= 300) {
|
return null;
|
}
|
long contentLength = connection.getContentLengthLong();
|
return contentLength > 0L ? contentLength : null;
|
} catch (Exception ex) {
|
return null;
|
} finally {
|
if (connection != null) {
|
connection.disconnect();
|
}
|
}
|
}
|
|
/**
|
* 若目标区间已包含在当前分段中，直接在内存切片避免二次请求。
|
*/
|
private byte[] extractBytesIfInsideChunk(byte[] chunkBytes, long chunkStart, ByteRange targetRange) {
|
if (chunkBytes == null || targetRange == null) {
|
return null;
|
}
|
long chunkEnd = chunkStart + chunkBytes.length - 1L;
|
if (targetRange.start < chunkStart || targetRange.end > chunkEnd) {
|
return null;
|
}
|
int offsetStart = (int) (targetRange.start - chunkStart);
|
int offsetEnd = (int) (targetRange.end - chunkStart);
|
byte[] targetBytes = new byte[offsetEnd - offsetStart + 1];
|
System.arraycopy(chunkBytes, offsetStart, targetBytes, 0, targetBytes.length);
|
return targetBytes;
|
}
|
|
/**
|
* 下载指定字节区间，优先用于头尾分段识别时长。
|
*/
|
private byte[] downloadRangeBytes(String videoUrl, long start, long end) throws IOException {
|
if (start < 0 || end < start) {
|
throw new IllegalArgumentException("视频地址范围不合法");
|
}
|
HttpURLConnection connection = null;
|
try {
|
connection = (HttpURLConnection) new URL(videoUrl).openConnection();
|
connection.setRequestMethod("GET");
|
applyConnectionConfig(connection);
|
connection.setRequestProperty("Range", "bytes=" + start + "-" + end);
|
int responseCode = connection.getResponseCode();
|
if (responseCode != HttpURLConnection.HTTP_PARTIAL
|
&& (responseCode < 200 || responseCode >= 300)) {
|
throw new IOException("range request failed");
|
}
|
try (InputStream inputStream = connection.getInputStream();
|
ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
|
byte[] buffer = new byte[8192];
|
int readLength;
|
int totalLength = 0;
|
while ((readLength = inputStream.read(buffer)) != -1) {
|
totalLength += readLength;
|
if (totalLength > MAX_RANGE_DETECT_BYTES) {
|
throw new IOException("range response too large");
|
}
|
outputStream.write(buffer, 0, readLength);
|
}
|
return outputStream.toByteArray();
|
}
|
} finally {
|
if (connection != null) {
|
connection.disconnect();
|
}
|
}
|
}
|
|
/**
|
* 统一设置 HTTP 请求超时和请求头。
|
*/
|
private void applyConnectionConfig(HttpURLConnection connection) {
|
connection.setConnectTimeout(CONNECT_TIMEOUT_MILLIS);
|
connection.setReadTimeout(READ_TIMEOUT_MILLIS);
|
connection.setInstanceFollowRedirects(true);
|
connection.setRequestProperty("User-Agent", "tcm-training-admin/1.0");
|
}
|
|
/**
|
* 下载远程视频字节流，供服务端解析媒体元数据。
|
*/
|
private byte[] downloadVideoBytes(String videoUrl) {
|
HttpURLConnection connection = null;
|
try {
|
connection = (HttpURLConnection) new URL(videoUrl).openConnection();
|
connection.setRequestMethod("GET");
|
applyConnectionConfig(connection);
|
int responseCode = connection.getResponseCode();
|
if (responseCode < 200 || responseCode >= 300) {
|
throw new IllegalArgumentException("无法获取视频文件，请检查视频地址");
|
}
|
try (InputStream inputStream = connection.getInputStream();
|
ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
|
byte[] buffer = new byte[8192];
|
int readLength;
|
int totalLength = 0;
|
while ((readLength = inputStream.read(buffer)) != -1) {
|
totalLength += readLength;
|
if (totalLength > MAX_DOWNLOAD_BYTES) {
|
throw new IllegalArgumentException("视频文件过大，无法自动识别时长，请手动填写");
|
}
|
outputStream.write(buffer, 0, readLength);
|
}
|
return outputStream.toByteArray();
|
}
|
} catch (IllegalArgumentException ex) {
|
throw ex;
|
} catch (IOException ex) {
|
throw new IllegalArgumentException("无法自动获取视频时长，请手动填写");
|
} finally {
|
if (connection != null) {
|
connection.disconnect();
|
}
|
}
|
}
|
|
/**
|
* 解析 MP4/QuickTime 文件中的 mvhd 盒子，换算为秒级时长。
|
*/
|
int parseDurationSeconds(byte[] videoBytes) {
|
if (videoBytes == null || videoBytes.length < 8) {
|
throw new IllegalArgumentException("无法自动获取视频时长，请手动填写");
|
}
|
long durationSeconds = findDurationSecondsInRange(videoBytes, 0, videoBytes.length);
|
if (durationSeconds <= 0L || durationSeconds > Integer.MAX_VALUE) {
|
throw new IllegalArgumentException("无法自动获取视频时长，请手动填写");
|
}
|
return (int) durationSeconds;
|
}
|
|
/**
|
* 尝试解析完整字节流时长，失败时返回 -1，供 Range 探测兜底流程使用。
|
*/
|
private int parseDurationSecondsSafely(byte[] videoBytes) {
|
try {
|
return parseDurationSeconds(videoBytes);
|
} catch (IllegalArgumentException ex) {
|
return -1;
|
}
|
}
|
|
/**
|
* 在尾部分段中按 moov 盒子位置解析时长。
|
*/
|
int parseDurationSecondsFromTailChunk(byte[] chunkBytes) {
|
if (chunkBytes == null || chunkBytes.length < 8) {
|
return -1;
|
}
|
long durationSeconds = findDurationSecondsFromChunkByMoov(chunkBytes);
|
if (durationSeconds <= 0L || durationSeconds > Integer.MAX_VALUE) {
|
return -1;
|
}
|
return (int) durationSeconds;
|
}
|
|
/**
|
* 在尾部分段中解析 moov 盒子的绝对字节区间。
|
*/
|
ByteRange resolveMoovRangeFromTailChunk(byte[] chunkBytes, long chunkStart, long totalLength) {
|
if (chunkBytes == null || chunkBytes.length < 8 || chunkStart < 0L || totalLength <= 0L) {
|
return null;
|
}
|
for (int typeOffset = chunkBytes.length - 4; typeOffset >= 4; typeOffset--) {
|
if (!isBoxType(chunkBytes, typeOffset, TYPE_MOOV)) {
|
continue;
|
}
|
int headerOffset = typeOffset - 4;
|
long boxSize = readUnsignedInt(chunkBytes, headerOffset);
|
int headerSize = 8;
|
if (boxSize == 1L) {
|
if (headerOffset + 16 > chunkBytes.length) {
|
continue;
|
}
|
boxSize = readUnsignedLong(chunkBytes, headerOffset + 8);
|
headerSize = 16;
|
}
|
if (boxSize != 0L && boxSize < headerSize) {
|
continue;
|
}
|
long boxStart = chunkStart + headerOffset;
|
long boxEnd = boxSize == 0L ? totalLength - 1L : boxStart + boxSize - 1L;
|
if (boxStart < 0L || boxEnd < boxStart || boxEnd >= totalLength) {
|
continue;
|
}
|
return new ByteRange(boxStart, boxEnd);
|
}
|
return null;
|
}
|
|
/**
|
* 在指定字节区间内递归查找 moov/mvhd 盒子。
|
*/
|
private long findDurationSecondsInRange(byte[] videoBytes, int start, int end) {
|
int offset = start;
|
while (offset + 8 <= end) {
|
long boxSize = readUnsignedInt(videoBytes, offset);
|
int headerSize = 8;
|
if (boxSize == 1L) {
|
if (offset + 16 > end) {
|
break;
|
}
|
boxSize = readUnsignedLong(videoBytes, offset + 8);
|
headerSize = 16;
|
} else if (boxSize == 0L) {
|
boxSize = end - offset;
|
}
|
if (boxSize < headerSize) {
|
break;
|
}
|
long boxEndLong = offset + boxSize;
|
if (boxEndLong > end) {
|
break;
|
}
|
int boxEnd = (int) boxEndLong;
|
String type = readBoxType(videoBytes, offset + 4);
|
if (TYPE_MOOV.equals(type)) {
|
long durationSeconds = findMovieHeaderDuration(videoBytes, offset + headerSize, boxEnd);
|
if (durationSeconds > 0L) {
|
return durationSeconds;
|
}
|
}
|
offset = boxEnd;
|
}
|
return -1L;
|
}
|
|
/**
|
* 从任意偏移分段中按 moov 盒子头定位并解析时长。
|
*/
|
private long findDurationSecondsFromChunkByMoov(byte[] chunkBytes) {
|
for (int typeOffset = 4; typeOffset + 4 <= chunkBytes.length; typeOffset++) {
|
if (!isBoxType(chunkBytes, typeOffset, TYPE_MOOV)) {
|
continue;
|
}
|
int boxHeaderOffset = typeOffset - 4;
|
long boxSize = readUnsignedInt(chunkBytes, boxHeaderOffset);
|
int headerSize = 8;
|
if (boxSize == 1L) {
|
if (boxHeaderOffset + 16 > chunkBytes.length) {
|
continue;
|
}
|
boxSize = readUnsignedLong(chunkBytes, boxHeaderOffset + 8);
|
headerSize = 16;
|
} else if (boxSize == 0L) {
|
boxSize = chunkBytes.length - boxHeaderOffset;
|
}
|
if (boxSize < headerSize) {
|
continue;
|
}
|
long boxEndLong = boxHeaderOffset + boxSize;
|
if (boxEndLong > chunkBytes.length) {
|
continue;
|
}
|
long durationSeconds = findMovieHeaderDuration(
|
chunkBytes,
|
boxHeaderOffset + headerSize,
|
(int) boxEndLong
|
);
|
if (durationSeconds > 0L) {
|
return durationSeconds;
|
}
|
}
|
return -1L;
|
}
|
|
/**
|
* 在 moov 盒子中查找 mvhd 头并解析时长。
|
*/
|
private long findMovieHeaderDuration(byte[] videoBytes, int start, int end) {
|
int offset = start;
|
while (offset + 8 <= end) {
|
long boxSize = readUnsignedInt(videoBytes, offset);
|
int headerSize = 8;
|
if (boxSize == 1L) {
|
if (offset + 16 > end) {
|
break;
|
}
|
boxSize = readUnsignedLong(videoBytes, offset + 8);
|
headerSize = 16;
|
} else if (boxSize == 0L) {
|
boxSize = end - offset;
|
}
|
if (boxSize < headerSize) {
|
break;
|
}
|
long boxEndLong = offset + boxSize;
|
if (boxEndLong > end) {
|
break;
|
}
|
int boxEnd = (int) boxEndLong;
|
String type = readBoxType(videoBytes, offset + 4);
|
if (TYPE_MVHD.equals(type)) {
|
return parseMovieHeaderDuration(videoBytes, offset + headerSize, boxEnd);
|
}
|
offset = boxEnd;
|
}
|
return -1L;
|
}
|
|
/**
|
* 解析 mvhd 盒子中的 timescale 与 duration。
|
*/
|
private long parseMovieHeaderDuration(byte[] videoBytes, int start, int end) {
|
if (start + 4 > end) {
|
return -1L;
|
}
|
int version = videoBytes[start] & 0xff;
|
long timescale;
|
long duration;
|
if (version == 1) {
|
if (start + 32 > end) {
|
return -1L;
|
}
|
timescale = readUnsignedInt(videoBytes, start + 20);
|
duration = readUnsignedLong(videoBytes, start + 24);
|
} else {
|
if (start + 20 > end) {
|
return -1L;
|
}
|
timescale = readUnsignedInt(videoBytes, start + 12);
|
duration = readUnsignedInt(videoBytes, start + 16);
|
}
|
if (timescale <= 0L || duration < 0L) {
|
return -1L;
|
}
|
return Math.round((double) duration / (double) timescale);
|
}
|
|
/**
|
* 读取 4 字节无符号整数。
|
*/
|
private long readUnsignedInt(byte[] bytes, int offset) {
|
return ((long) bytes[offset] & 0xffL) << 24
|
| ((long) bytes[offset + 1] & 0xffL) << 16
|
| ((long) bytes[offset + 2] & 0xffL) << 8
|
| ((long) bytes[offset + 3] & 0xffL);
|
}
|
|
/**
|
* 读取 8 字节无符号整数的长整型表示。
|
*/
|
private long readUnsignedLong(byte[] bytes, int offset) {
|
return ((long) bytes[offset] & 0xffL) << 56
|
| ((long) bytes[offset + 1] & 0xffL) << 48
|
| ((long) bytes[offset + 2] & 0xffL) << 40
|
| ((long) bytes[offset + 3] & 0xffL) << 32
|
| ((long) bytes[offset + 4] & 0xffL) << 24
|
| ((long) bytes[offset + 5] & 0xffL) << 16
|
| ((long) bytes[offset + 6] & 0xffL) << 8
|
| ((long) bytes[offset + 7] & 0xffL);
|
}
|
|
/**
|
* 读取盒子类型。
|
*/
|
private String readBoxType(byte[] bytes, int offset) {
|
return new String(bytes, offset, 4, StandardCharsets.US_ASCII);
|
}
|
|
/**
|
* 判断指定偏移是否匹配目标盒子类型。
|
*/
|
private boolean isBoxType(byte[] bytes, int typeOffset, String expectedType) {
|
if (typeOffset < 0 || typeOffset + 4 > bytes.length || expectedType == null || expectedType.length() != 4) {
|
return false;
|
}
|
return bytes[typeOffset] == (byte) expectedType.charAt(0)
|
&& bytes[typeOffset + 1] == (byte) expectedType.charAt(1)
|
&& bytes[typeOffset + 2] == (byte) expectedType.charAt(2)
|
&& bytes[typeOffset + 3] == (byte) expectedType.charAt(3);
|
}
|
|
/**
|
* 表示远程文件中的闭区间字节范围。
|
*/
|
static final class ByteRange {
|
private final long start;
|
private final long end;
|
|
ByteRange(long start, long end) {
|
this.start = start;
|
this.end = end;
|
}
|
|
long getStart() {
|
return start;
|
}
|
|
long getEnd() {
|
return end;
|
}
|
}
|
}
|
