package com.doumee.service.business.impl.collection;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.doumee.biz.system.SystemDictDataBiz;
|
import com.doumee.core.constants.ResponseStatus;
|
import com.doumee.core.exception.BusinessException;
|
import com.doumee.core.utils.Constants;
|
import com.doumee.core.utils.DateUtil;
|
import com.doumee.core.utils.FtpUtil;
|
import com.doumee.service.business.collection.CollectionMediaConstants;
|
import com.doumee.service.business.collection.MediaFrameUtil;
|
import com.doumee.dao.admin.request.DeliverySnapshotManualRequest;
|
import com.doumee.dao.business.CollectionMediaMapper;
|
import com.doumee.dao.business.DeliveryMediaSnapshotFeedbackMapper;
|
import com.doumee.dao.business.DeliveryMediaSnapshotMapper;
|
import com.doumee.dao.business.model.CollectionMedia;
|
import com.doumee.dao.business.model.DeliveryMediaSnapshot;
|
import com.doumee.dao.business.model.DeliveryMediaSnapshotFeedback;
|
import com.doumee.service.business.DeliverySnapshotService;
|
import com.doumee.service.business.snapshot.SnapshotAnalyzeRequest;
|
import com.doumee.service.business.snapshot.SnapshotAnalyzeResponse;
|
import com.doumee.service.business.snapshot.SnapshotInferClient;
|
import com.doumee.service.business.snapshot.SnapshotInferProperties;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import javax.annotation.Resource;
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.IOException;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.UUID;
|
import java.util.concurrent.Executor;
|
|
@Slf4j
|
@Service
|
public class DeliverySnapshotServiceImpl implements DeliverySnapshotService {
|
|
@Autowired
|
private CollectionMediaMapper collectionMediaMapper;
|
@Autowired
|
private DeliveryMediaSnapshotMapper deliveryMediaSnapshotMapper;
|
@Autowired
|
private DeliveryMediaSnapshotFeedbackMapper deliveryMediaSnapshotFeedbackMapper;
|
@Autowired
|
private SystemDictDataBiz systemDictDataBiz;
|
@Autowired
|
private SnapshotInferClient snapshotInferClient;
|
@Autowired
|
private SnapshotInferProperties snapshotInferProperties;
|
@Resource(name = "asyncExecutor")
|
private Executor asyncExecutor;
|
|
@Override
|
public String submitAnalyze(Integer mediaId) {
|
CollectionMedia media = requireDownloadedMedia(mediaId);
|
if (Constants.equalsInteger(media.getSnapshotStatus(), CollectionMediaConstants.SNAPSHOT_STATUS_PROCESSING)) {
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "快照分析进行中，请稍后刷新");
|
}
|
markSnapshotProcessing(mediaId);
|
asyncExecutor.execute(() -> executeAnalyze(mediaId));
|
return "已提交快照分析任务，请稍后刷新查看";
|
}
|
|
@Override
|
public void submitAnalyzeAsync(Integer mediaId) {
|
if (!snapshotInferProperties.isAutoOnDownload()) {
|
return;
|
}
|
try {
|
CollectionMedia media = collectionMediaMapper.selectById(mediaId);
|
if (media == null || Constants.equalsInteger(media.getIsdeleted(), Constants.ONE)) {
|
return;
|
}
|
if (!Constants.equalsInteger(media.getDownloadStatus(), Constants.ONE)
|
|| StringUtils.isBlank(media.getFilePathLocal())) {
|
return;
|
}
|
if (Constants.equalsInteger(media.getSnapshotStatus(), CollectionMediaConstants.SNAPSHOT_STATUS_PROCESSING)
|
|| Constants.equalsInteger(media.getSnapshotStatus(), CollectionMediaConstants.SNAPSHOT_STATUS_DONE)) {
|
return;
|
}
|
if (media.getMediaType() != null && media.getMediaType() != 0) {
|
return;
|
}
|
markSnapshotProcessing(mediaId);
|
asyncExecutor.execute(() -> executeAnalyze(mediaId));
|
} catch (Exception e) {
|
log.warn("自动提交快照分析失败 mediaId={}: {}", mediaId, e.getMessage());
|
}
|
}
|
|
@Override
|
public List<DeliveryMediaSnapshot> listByMediaId(Integer mediaId) {
|
List<DeliveryMediaSnapshot> list = deliveryMediaSnapshotMapper.selectList(new QueryWrapper<DeliveryMediaSnapshot>().lambda()
|
.eq(DeliveryMediaSnapshot::getMediaId, mediaId)
|
.eq(DeliveryMediaSnapshot::getIsdeleted, Constants.ZERO)
|
.orderByAsc(DeliveryMediaSnapshot::getSnapshotType));
|
list.forEach(this::fillSnapshotUrl);
|
return list;
|
}
|
|
@Override
|
public String saveManual(DeliverySnapshotManualRequest request) {
|
if (request == null || request.getMediaId() == null || request.getSnapshotType() == null
|
|| request.getTimestampSec() == null) {
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "参数不完整");
|
}
|
if (!Constants.equalsInteger(request.getSnapshotType(), CollectionMediaConstants.SNAPSHOT_TYPE_STOREFRONT)
|
&& !Constants.equalsInteger(request.getSnapshotType(), CollectionMediaConstants.SNAPSHOT_TYPE_HANDOVER)) {
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "快照类型无效");
|
}
|
CollectionMedia media = requireDownloadedMedia(request.getMediaId());
|
File videoFile = null;
|
File frameFile = null;
|
try {
|
videoFile = downloadMediaToTemp(media);
|
frameFile = File.createTempFile("hk_snapshot_", ".jpg");
|
if (!MediaFrameUtil.extractFrame(getFfmpegPath(), videoFile, frameFile, request.getTimestampSec().doubleValue())) {
|
throw new BusinessException(ResponseStatus.SERVER_ERROR.getCode(), "截帧失败");
|
}
|
String relativePath = uploadSnapshot(frameFile, media.getId(), request.getSnapshotType());
|
saveFeedback(media.getId(), request.getSnapshotType(), request.getTimestampSec());
|
upsertSnapshot(media.getId(), request.getSnapshotType(), request.getTimestampSec(),
|
relativePath, null, "manual", null);
|
CollectionMedia update = new CollectionMedia();
|
update.setId(media.getId());
|
update.setSnapshotStatus(CollectionMediaConstants.SNAPSHOT_STATUS_DONE);
|
update.setSnapshotTime(new Date());
|
update.setSnapshotMessage(null);
|
collectionMediaMapper.updateById(update);
|
return "保存成功";
|
} catch (BusinessException e) {
|
throw e;
|
} catch (Exception e) {
|
log.error("手动保存快照失败 mediaId={}: {}", request.getMediaId(), e.getMessage(), e);
|
throw new BusinessException(ResponseStatus.SERVER_ERROR.getCode(), "保存快照失败");
|
} finally {
|
deleteQuietly(videoFile);
|
deleteQuietly(frameFile);
|
}
|
}
|
|
private void executeAnalyze(Integer mediaId) {
|
CollectionMedia media = collectionMediaMapper.selectById(mediaId);
|
if (media == null || Constants.equalsInteger(media.getIsdeleted(), Constants.ONE)) {
|
return;
|
}
|
File videoFile = null;
|
File storefrontFrame = null;
|
File handoverFrame = null;
|
try {
|
videoFile = downloadMediaToTemp(media);
|
double duration = MediaFrameUtil.probeDurationSec(getFfmpegPath(), videoFile);
|
if (duration <= 0) {
|
duration = estimateDuration(media);
|
}
|
SnapshotAnalyzeRequest analyzeRequest = new SnapshotAnalyzeRequest();
|
analyzeRequest.setMediaId(mediaId);
|
analyzeRequest.setVideoUrl(buildVideoUrl(media));
|
analyzeRequest.setSampleFps(snapshotInferProperties.getSampleFps());
|
analyzeRequest.setEnableAsr(snapshotInferProperties.isEnableAsr());
|
analyzeRequest.setDurationSec(duration);
|
SnapshotAnalyzeResponse analyzeResponse = snapshotInferClient.analyze(analyzeRequest);
|
if (Boolean.FALSE.equals(analyzeResponse.getSuccess())) {
|
throw new BusinessException(ResponseStatus.SERVER_ERROR.getCode(),
|
StringUtils.defaultIfBlank(analyzeResponse.getMessage(), "快照推理失败"));
|
}
|
|
double storefrontSec = analyzeResponse.getStorefront().getTimeSec();
|
double handoverSec = analyzeResponse.getHandover().getTimeSec();
|
if (handoverSec <= storefrontSec) {
|
handoverSec = Math.min(duration > 0 ? duration - 1 : storefrontSec + 60, storefrontSec + 60);
|
}
|
|
storefrontFrame = File.createTempFile("hk_storefront_", ".jpg");
|
handoverFrame = File.createTempFile("hk_handover_", ".jpg");
|
if (!MediaFrameUtil.extractFrame(getFfmpegPath(), videoFile, storefrontFrame, storefrontSec)) {
|
throw new BusinessException(ResponseStatus.SERVER_ERROR.getCode(), "门头图截帧失败");
|
}
|
if (!MediaFrameUtil.extractFrame(getFfmpegPath(), videoFile, handoverFrame, handoverSec)) {
|
throw new BusinessException(ResponseStatus.SERVER_ERROR.getCode(), "交付图截帧失败");
|
}
|
|
String storefrontPath = uploadSnapshot(storefrontFrame, mediaId, CollectionMediaConstants.SNAPSHOT_TYPE_STOREFRONT);
|
String handoverPath = uploadSnapshot(handoverFrame, mediaId, CollectionMediaConstants.SNAPSHOT_TYPE_HANDOVER);
|
|
upsertSnapshot(mediaId, CollectionMediaConstants.SNAPSHOT_TYPE_STOREFRONT,
|
BigDecimal.valueOf(storefrontSec).setScale(2, RoundingMode.HALF_UP),
|
storefrontPath,
|
analyzeResponse.getStorefront().getConfidence(),
|
StringUtils.defaultIfBlank(analyzeResponse.getStorefront().getSource(), "ai"),
|
analyzeResponse.getModelVersion());
|
upsertSnapshot(mediaId, CollectionMediaConstants.SNAPSHOT_TYPE_HANDOVER,
|
BigDecimal.valueOf(handoverSec).setScale(2, RoundingMode.HALF_UP),
|
handoverPath,
|
analyzeResponse.getHandover().getConfidence(),
|
StringUtils.defaultIfBlank(analyzeResponse.getHandover().getSource(), "ai"),
|
analyzeResponse.getModelVersion());
|
|
CollectionMedia done = new CollectionMedia();
|
done.setId(mediaId);
|
done.setSnapshotStatus(CollectionMediaConstants.SNAPSHOT_STATUS_DONE);
|
done.setSnapshotTime(new Date());
|
done.setSnapshotMessage(null);
|
collectionMediaMapper.updateById(done);
|
log.info("快照分析完成 mediaId={} storefrontSec={} handoverSec={}", mediaId, storefrontSec, handoverSec);
|
} catch (Exception e) {
|
log.error("快照分析失败 mediaId={}: {}", mediaId, e.getMessage(), e);
|
CollectionMedia fail = new CollectionMedia();
|
fail.setId(mediaId);
|
fail.setSnapshotStatus(CollectionMediaConstants.SNAPSHOT_STATUS_FAILED);
|
fail.setSnapshotMessage(StringUtils.left(e.getMessage(), 500));
|
collectionMediaMapper.updateById(fail);
|
} finally {
|
deleteQuietly(videoFile);
|
deleteQuietly(storefrontFrame);
|
deleteQuietly(handoverFrame);
|
}
|
}
|
|
private void markSnapshotProcessing(Integer mediaId) {
|
CollectionMedia processing = new CollectionMedia();
|
processing.setId(mediaId);
|
processing.setSnapshotStatus(CollectionMediaConstants.SNAPSHOT_STATUS_PROCESSING);
|
processing.setSnapshotMessage(null);
|
collectionMediaMapper.updateById(processing);
|
}
|
|
private CollectionMedia requireDownloadedMedia(Integer mediaId) {
|
CollectionMedia media = collectionMediaMapper.selectById(mediaId);
|
if (media == null || Constants.equalsInteger(media.getIsdeleted(), Constants.ONE)) {
|
throw new BusinessException(ResponseStatus.DATA_EMPTY);
|
}
|
if (!Constants.equalsInteger(media.getDownloadStatus(), Constants.ONE)
|
|| StringUtils.isBlank(media.getFilePathLocal())) {
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "请先下载媒体文件");
|
}
|
return media;
|
}
|
|
private File downloadMediaToTemp(CollectionMedia media) throws IOException {
|
FtpUtil ftp = createFtpClient();
|
File temp = File.createTempFile("hk_media_snap_", resolveSuffix(media));
|
String remote = getMediaFolder() + media.getFilePathLocal();
|
String local = ftp.download(remote, temp.getAbsolutePath());
|
if (StringUtils.isBlank(local)) {
|
ftp.disconnect();
|
throw new BusinessException(ResponseStatus.SERVER_ERROR.getCode(), "下载媒体文件失败");
|
}
|
ftp.disconnect();
|
return temp;
|
}
|
|
private String uploadSnapshot(File frameFile, Integer mediaId, int snapshotType) throws IOException {
|
FtpUtil ftp = createFtpClient();
|
try {
|
String folder = getSnapshotFolder();
|
String suffix = snapshotType == CollectionMediaConstants.SNAPSHOT_TYPE_STOREFRONT ? "_storefront.jpg" : "_handover.jpg";
|
String relative = DateUtil.getNowShortDate() + "/" + mediaId + suffix;
|
String remote = folder + relative;
|
try (FileInputStream in = new FileInputStream(frameFile)) {
|
if (!ftp.uploadInputstream(in, remote)) {
|
throw new BusinessException(ResponseStatus.SERVER_ERROR.getCode(), "上传快照失败");
|
}
|
}
|
return relative;
|
} finally {
|
ftp.disconnect();
|
}
|
}
|
|
private void upsertSnapshot(Integer mediaId, int snapshotType, BigDecimal timestampSec, String filePath,
|
Double confidence, String source, String modelVersion) {
|
deliveryMediaSnapshotMapper.update(null, new UpdateWrapper<DeliveryMediaSnapshot>().lambda()
|
.eq(DeliveryMediaSnapshot::getMediaId, mediaId)
|
.eq(DeliveryMediaSnapshot::getSnapshotType, snapshotType)
|
.set(DeliveryMediaSnapshot::getIsdeleted, Constants.ONE));
|
DeliveryMediaSnapshot row = new DeliveryMediaSnapshot();
|
row.setMediaId(mediaId);
|
row.setSnapshotType(snapshotType);
|
row.setTimestampSec(timestampSec);
|
row.setFilePath(filePath);
|
if (confidence != null) {
|
row.setConfidence(BigDecimal.valueOf(confidence).setScale(4, RoundingMode.HALF_UP));
|
}
|
row.setSource(source);
|
row.setModelVersion(modelVersion);
|
row.setCreateDate(new Date());
|
row.setIsdeleted(Constants.ZERO);
|
deliveryMediaSnapshotMapper.insert(row);
|
}
|
|
private void fillSnapshotUrl(DeliveryMediaSnapshot snapshot) {
|
if (StringUtils.isBlank(snapshot.getFilePath())) {
|
return;
|
}
|
try {
|
String prefix = systemDictDataBiz.queryByCode(Constants.FTP, Constants.FTP_RESOURCE_PATH).getCode();
|
snapshot.setFileUrlFull(prefix + getSnapshotFolder() + snapshot.getFilePath());
|
} catch (Exception e) {
|
log.warn("构建快照URL失败 id={}: {}", snapshot.getId(), e.getMessage());
|
}
|
}
|
|
private String buildVideoUrl(CollectionMedia media) {
|
try {
|
String prefix = systemDictDataBiz.queryByCode(Constants.FTP, Constants.FTP_RESOURCE_PATH).getCode();
|
return prefix + getMediaFolder() + media.getFilePathLocal();
|
} catch (Exception e) {
|
return null;
|
}
|
}
|
|
private double estimateDuration(CollectionMedia media) {
|
if (media.getStartTime() != null && media.getEndTime() != null) {
|
long ms = media.getEndTime().getTime() - media.getStartTime().getTime();
|
if (ms > 0) {
|
return ms / 1000.0;
|
}
|
}
|
return 1200.0;
|
}
|
|
private FtpUtil createFtpClient() throws IOException {
|
return new FtpUtil(
|
systemDictDataBiz.queryByCode(Constants.FTP, Constants.FTP_HOST).getCode(),
|
Integer.parseInt(systemDictDataBiz.queryByCode(Constants.FTP, Constants.FTP_PORT).getCode()),
|
systemDictDataBiz.queryByCode(Constants.FTP, Constants.FTP_USERNAME).getCode(),
|
systemDictDataBiz.queryByCode(Constants.FTP, Constants.FTP_PWD).getCode());
|
}
|
|
private String getMediaFolder() {
|
try {
|
return systemDictDataBiz.queryByCode(Constants.FTP, Constants.COLLECTION_MEDIA_FOLDER).getCode();
|
} catch (Exception e) {
|
return "/collection_media/";
|
}
|
}
|
|
private String getSnapshotFolder() {
|
try {
|
return systemDictDataBiz.queryByCode(Constants.FTP, CollectionMediaConstants.COLLECTION_SNAPSHOT_FOLDER).getCode();
|
} catch (Exception e) {
|
return "/collection_snapshot/";
|
}
|
}
|
|
private String getFfmpegPath() {
|
try {
|
return systemDictDataBiz.queryByCode(Constants.CS_PARAM, Constants.CS_FFMPEG_PATH).getCode();
|
} catch (Exception e) {
|
return "ffmpeg";
|
}
|
}
|
|
private String resolveSuffix(CollectionMedia media) {
|
if (StringUtils.isNotBlank(media.getFileName()) && media.getFileName().contains(".")) {
|
return media.getFileName().substring(media.getFileName().lastIndexOf('.')).toLowerCase();
|
}
|
return ".mp4";
|
}
|
|
private void saveFeedback(Integer mediaId, int snapshotType, BigDecimal manualTimeSec) {
|
DeliveryMediaSnapshot existing = deliveryMediaSnapshotMapper.selectOne(new QueryWrapper<DeliveryMediaSnapshot>().lambda()
|
.eq(DeliveryMediaSnapshot::getMediaId, mediaId)
|
.eq(DeliveryMediaSnapshot::getSnapshotType, snapshotType)
|
.eq(DeliveryMediaSnapshot::getIsdeleted, Constants.ZERO)
|
.orderByDesc(DeliveryMediaSnapshot::getId)
|
.last("LIMIT 1"));
|
DeliveryMediaSnapshotFeedback feedback = new DeliveryMediaSnapshotFeedback();
|
feedback.setMediaId(mediaId);
|
feedback.setSnapshotType(snapshotType);
|
if (existing != null && existing.getTimestampSec() != null) {
|
feedback.setAiTimeSec(existing.getTimestampSec());
|
feedback.setModelVersion(existing.getModelVersion());
|
}
|
feedback.setManualTimeSec(manualTimeSec);
|
feedback.setCreateDate(new Date());
|
feedback.setIsdeleted(Constants.ZERO);
|
deliveryMediaSnapshotFeedbackMapper.insert(feedback);
|
}
|
|
private void deleteQuietly(File file) {
|
if (file != null && file.exists() && !file.delete()) {
|
log.warn("临时文件删除失败: {}", file.getAbsolutePath());
|
}
|
}
|
|
}
|
