483 lines
20 KiB
Java
483 lines
20 KiB
Java
package com.yutou.bilibili.services;
|
||
|
||
import com.alibaba.fastjson2.JSONArray;
|
||
import com.alibaba.fastjson2.JSONObject;
|
||
import com.alibaba.fastjson2.util.DateUtils;
|
||
import com.yutou.biliapi.api.LiveApi;
|
||
import com.yutou.biliapi.bean.live.LiveRoomConfig;
|
||
import com.yutou.biliapi.bean.live.LiveRoomInfo;
|
||
import com.yutou.biliapi.bean.live.LiveRoomPlayInfo;
|
||
import com.yutou.biliapi.bean.live.database.LiveConfigDatabaseBean;
|
||
import com.yutou.biliapi.bean.live.database.LiveVideoDatabaseBean;
|
||
import com.yutou.biliapi.bean.login.LoginCookieDatabaseBean;
|
||
import com.yutou.biliapi.databases.BiliBiliLoginDatabase;
|
||
import com.yutou.biliapi.databases.BiliLiveConfigDatabase;
|
||
import com.yutou.biliapi.databases.BiliLiveDatabase;
|
||
import com.yutou.biliapi.enums.LiveProtocol;
|
||
import com.yutou.biliapi.enums.LiveVideoCodec;
|
||
import com.yutou.biliapi.enums.LiveVideoDefinition;
|
||
import com.yutou.biliapi.enums.LiveVideoFormat;
|
||
import com.yutou.biliapi.net.BiliLiveNetApiManager;
|
||
import com.yutou.biliapi.net.WebSocketServer;
|
||
import com.yutou.bilibili.Tools.DateFormatUtils;
|
||
import com.yutou.bilibili.Tools.FileServerUtils;
|
||
import com.yutou.bilibili.datas.VideoFilePath;
|
||
import com.yutou.bilibili.interfaces.DownloadInterface;
|
||
import com.yutou.common.okhttp.HttpCallback;
|
||
import com.yutou.common.okhttp.HttpDownloadUtils;
|
||
import com.yutou.common.record.AbsVideoRecord;
|
||
import com.yutou.common.utils.ConfigTools;
|
||
import com.yutou.common.utils.FFmpegUtils;
|
||
import com.yutou.common.utils.Log;
|
||
import jakarta.annotation.Resource;
|
||
import okhttp3.Headers;
|
||
import org.apache.commons.io.FileUtils;
|
||
import org.springframework.stereotype.Service;
|
||
import org.springframework.util.StringUtils;
|
||
|
||
import java.io.File;
|
||
import java.io.IOException;
|
||
import java.util.*;
|
||
import java.util.concurrent.ArrayBlockingQueue;
|
||
import java.util.concurrent.ThreadPoolExecutor;
|
||
import java.util.concurrent.TimeUnit;
|
||
|
||
import static com.alibaba.fastjson2.util.DateUtils.DateTimeFormatPattern.DATE_FORMAT_10_DASH;
|
||
|
||
@Service
|
||
public class LiveVideoDownloadService {
|
||
private final ThreadPoolExecutor executor;
|
||
private final List<String> userStopList = new ArrayList<>();//手动停止列表
|
||
private final AbsVideoRecord videoRecord;
|
||
@Resource
|
||
LiveDatabasesService liveDatabasesService;
|
||
@Resource
|
||
WebSocketServer webSocketServer;
|
||
|
||
public LiveVideoDownloadService() {
|
||
Log.i("初始化下载服务");
|
||
videoRecord = new FFmpegUtils();
|
||
executor = new ThreadPoolExecutor(2, 4, Long.MAX_VALUE, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(100));
|
||
}
|
||
|
||
public boolean checkDownload(String roomId) {
|
||
return videoRecord.check(roomId);
|
||
}
|
||
|
||
public void clearUserStopList() {
|
||
userStopList.clear();
|
||
}
|
||
public void removeUserStopList(String roomId) {
|
||
userStopList.remove(roomId);
|
||
}
|
||
public boolean isUserStopList(String roomId) {
|
||
return userStopList.contains(roomId);
|
||
}
|
||
|
||
public void start(LiveConfigDatabaseBean bean, boolean isUser) {
|
||
if (!isUser && userStopList.contains(bean.getRoomId())) {
|
||
return;
|
||
}
|
||
if (isUser) {
|
||
userStopList.remove(bean.getRoomId());
|
||
}
|
||
if (videoRecord.check(bean.getRoomId())) {
|
||
return;
|
||
}
|
||
BiliLiveNetApiManager.getInstance().getApi(bean.getRecordUid()).getRoomInfo(bean.getRoomId()).enqueue(new HttpCallback<LiveRoomInfo>() {
|
||
@Override
|
||
public void onResponse(Headers headers, int code, String status, LiveRoomInfo response, String rawResponse) {
|
||
if (response.getLiveStatus() == 1) {
|
||
if (bean.getKeywordList()!=null&&!bean.getKeywordList().isEmpty() && !isUser) {
|
||
String foundKey = bean.getKeywordList().stream()
|
||
.filter(key -> response.getTitle().contains(key))
|
||
.findFirst()
|
||
.orElse(null);
|
||
|
||
if (foundKey != null) {
|
||
Log.i(response.getRoomId(), "检测到开播关键词", foundKey, response.getTitle());
|
||
} else {
|
||
Log.i(response.getRoomId(), "未检测到关键词", response.getTitle(), Arrays.toString(bean.getKeywordList().toArray()));
|
||
return;
|
||
}
|
||
}
|
||
VideoTask task = new VideoTask(bean, response);
|
||
executor.execute(task);
|
||
} else {
|
||
Log.i(bean.getRoomId(), "没有开播");
|
||
}
|
||
}
|
||
|
||
@Override
|
||
public void onFailure(Throwable throwable) {
|
||
Log.e(throwable, "移除下载");
|
||
}
|
||
});
|
||
|
||
|
||
}
|
||
|
||
public void stop(String roomId, boolean isUser) {
|
||
if (isUser) {
|
||
userStopList.add(roomId);
|
||
}
|
||
videoRecord.kill(roomId);
|
||
}
|
||
|
||
|
||
public JSONArray getDownloadTasks() {
|
||
JSONArray array = new JSONArray();
|
||
array.addAll(videoRecord.getRoomIds());
|
||
return array;
|
||
}
|
||
|
||
public void stopAll() {
|
||
videoRecord.killAll();
|
||
}
|
||
|
||
private class VideoTask implements Runnable {
|
||
LiveConfigDatabaseBean bean;
|
||
boolean isDownload = true;
|
||
LiveApi api;
|
||
String savePath;
|
||
File rootPath;
|
||
LiveConfigDatabaseBean config;
|
||
LiveVideoDatabaseBean videoDatabaseBean = null;
|
||
LiveRoomInfo roomInfo;
|
||
|
||
public VideoTask(LiveConfigDatabaseBean bean, LiveRoomInfo roomInfo) {
|
||
this.bean = bean;
|
||
this.roomInfo = roomInfo;
|
||
api = BiliLiveNetApiManager.getInstance().getApi(bean.getRecordUid());
|
||
}
|
||
|
||
|
||
@Override
|
||
public void run() {
|
||
if (roomInfo.getLiveStatus() == 1) {
|
||
String time = DateUtils.format(new Date().getTime(), DATE_FORMAT_10_DASH);
|
||
rootPath = new File(bean.getRecordPath() + File.separator + bean.getAnchorName() + File.separator + time + File.separator + "[" +
|
||
DateUtils.format(new Date(),
|
||
"HH-mm-ss") + "]" + roomInfo.getTitle());
|
||
savePath = rootPath.getAbsolutePath() + File.separator + roomInfo.getTitle() + ".m3u8";
|
||
if (!rootPath.exists()) {
|
||
rootPath.mkdirs();
|
||
}
|
||
record(bean, roomInfo);
|
||
} else {
|
||
stop();
|
||
}
|
||
}
|
||
|
||
private void stop() {
|
||
videoRecord.kill(bean.getRoomId());
|
||
api.getRoomInfo(config.getRoomId()).enqueue(new HttpCallback<LiveRoomInfo>() {
|
||
@Override
|
||
public void onResponse(Headers headers, int code, String status, LiveRoomInfo response, String rawResponse) {
|
||
if (response.getLiveStatus() == 1) {
|
||
LiveVideoDownloadService.this.start(bean, false);
|
||
} else {
|
||
LiveVideoDownloadService.this.stop(bean.getRoomId(), false);
|
||
}
|
||
}
|
||
|
||
@Override
|
||
public void onFailure(Throwable throwable) {
|
||
|
||
}
|
||
});
|
||
|
||
}
|
||
|
||
private void record(LiveConfigDatabaseBean bean, LiveRoomInfo roomInfo) {
|
||
this.config = bean;
|
||
isDownload = true;
|
||
LiveRoomConfig config = new LiveRoomConfig();
|
||
config.setLoginUid(bean.getRecordUid());
|
||
config.setRoomId(bean.getRoomId());
|
||
config.setAnchorName(bean.getAnchorName());
|
||
config.setLogin(StringUtils.hasText(bean.getRecordUid()));
|
||
config.setRoomInfo(roomInfo);
|
||
config.setRootPath(bean.getRecordPath());
|
||
saveLiveInfo(roomInfo);
|
||
api.getLiveRoomPlayInfo(
|
||
bean.getRoomId(),
|
||
LiveProtocol.getAll(),
|
||
LiveVideoFormat.getAll(),
|
||
LiveVideoCodec.getAll(),
|
||
LiveVideoDefinition.ORIGINAL.getValue()).enqueue(new HttpCallback<LiveRoomPlayInfo>() {
|
||
@Override
|
||
public void onResponse(Headers headers, int code, String status, LiveRoomPlayInfo response, String rawResponse) {
|
||
Random random = new Random();
|
||
List<LiveRoomPlayInfo.Stream> streams = response.getPlayurlInfo().getPlayurl().getStream();
|
||
List<LiveRoomPlayInfo.Stream> streamList = streams.stream()
|
||
.filter(it -> "http_stream".equals(it.getProtocolName()))
|
||
.toList();
|
||
|
||
LiveRoomPlayInfo.Stream stream = streamList.get(random.nextInt(streamList.size()));
|
||
if (stream == null) {
|
||
return;
|
||
}
|
||
List<LiveRoomPlayInfo.Format> formats = stream.getFormat().stream().filter(it -> "flv".equals(it.getFormatName())).toList();
|
||
LiveRoomPlayInfo.Format format = formats.get(random.nextInt(formats.size()));
|
||
|
||
List<LiveRoomPlayInfo.Codec> codecs = format.getCodec().stream().filter(item -> "avc".equals(item.getCodecName())).toList();
|
||
|
||
LiveRoomPlayInfo.Codec codec = codecs.get(random.nextInt(codecs.size()));
|
||
|
||
int urlIndex = random.nextInt(codec.getUrlInfo().size());
|
||
LiveRoomPlayInfo.UrlInfo urlInfo = codec.getUrlInfo().get(urlIndex);
|
||
|
||
|
||
String url = urlInfo.getHost() + codec.getBaseUrl() + urlInfo.getExtra();
|
||
Log.i("下载直播", rawResponse, codec.toString(), urlInfo.toString(), "URL:" + url);
|
||
|
||
if (bean.getRecordLiveModel() == 1) {
|
||
javaRecord(url, response);
|
||
} else {
|
||
ffmpeg(url, response);
|
||
}
|
||
}
|
||
|
||
@Override
|
||
public void onFailure(Throwable throwable) {
|
||
Log.e(throwable);
|
||
}
|
||
});
|
||
}
|
||
|
||
private void javaRecord(String url, LiveRoomPlayInfo playInfo) {
|
||
|
||
HttpDownloadUtils.download(new HttpDownloadUtils.Builder()
|
||
.setUrl(url)
|
||
.setPath(savePath)
|
||
.setDownloadInterface(new DownloadInterface() {
|
||
@Override
|
||
public void onDownloadStart() {
|
||
super.onDownloadStart();
|
||
VideoTask.this.onStart();
|
||
}
|
||
|
||
@Override
|
||
public boolean onDownloading(double soFarBytes, double totalBytes) {
|
||
return isDownload;
|
||
}
|
||
|
||
@Override
|
||
public void onDownload(File file) {
|
||
super.onDownload(file);
|
||
stop();
|
||
}
|
||
|
||
@Override
|
||
public void onError(Exception e) {
|
||
super.onError(e);
|
||
stop();
|
||
}
|
||
}));
|
||
}
|
||
|
||
private void ffmpeg(String url, LiveRoomPlayInfo playInfo) {
|
||
String ffmpegPath = ConfigTools.load(ConfigTools.CONFIG, "ffmpeg", String.class);
|
||
String cookie = "";
|
||
LoginCookieDatabaseBean ck = BiliBiliLoginDatabase.getInstance().getCookie(config.getRecordUid());
|
||
if (ck != null) {
|
||
cookie = ck.toCookieString();
|
||
}
|
||
|
||
FFmpegUtils.Builder builder = new FFmpegUtils.Builder()
|
||
.withParam("-user_agent", ConfigTools.getUserAgent())
|
||
.withParam("-headers", "Referer: https://live.bilibili.com/" + playInfo.getRoomId())
|
||
// .withNotSymbolParam("-reconnect", "1")
|
||
// .withNotSymbolParam("-reconnect_at_eof", "1")
|
||
// .withNotSymbolParam("-reconnect_streamed", "1")
|
||
// .withNotSymbolParam("-reconnect_delay_max", "2")
|
||
// .withNotSymbolParam("-loglevel", "error")
|
||
// .withNotSymbolParam("-progress", "-")
|
||
// .withNotSymbolParam("-fflags", "+genpts")
|
||
// .withNotSymbolParam("-threads", "8")//看bili-go也没有加这个，改成设置好了
|
||
// .withNotSymbolParam("-bufsize", "10M")
|
||
.withNotSymbolParam("-f", "segment")
|
||
.withNotSymbolParam("-rw_timeout", "60000000")
|
||
.withNotSymbolParam("-segment_time", "60")
|
||
.withNotSymbolParam("-segment_format", "mpegts")
|
||
.withNotSymbolParam("-map", "0")
|
||
.withParam("-segment_list", savePath)
|
||
.withNotSymbolParam("-c", "copy")
|
||
.withNotSymbolParam("-bsf:a", "aac_adtstoasc")
|
||
// .withNotSymbolParam("-loglevel", "debug")
|
||
.withNotSymbolParam("-y", "")
|
||
// .withNotSymbolParam("-progress",new File("cache",config.getRoomId()+".txt").getAbsolutePath()); //输出进度日志,暂时没啥用
|
||
;
|
||
if (ck != null) {
|
||
// builder = builder.withParam("-cookies", cookie);
|
||
}
|
||
FFmpegUtils command = builder.build(config.getRoomId(), ffmpegPath, url, savePath.replace(".m3u8", "-%04d.ts"));
|
||
Log.i(command.getCommandDecode());
|
||
try {
|
||
command.start(new DownloadInterface() {
|
||
TimerTask task = null;
|
||
|
||
@Override
|
||
public void onDownloadStart() {
|
||
super.onDownloadStart();
|
||
task = new TimerTask() {
|
||
@Override
|
||
public void run() {
|
||
VideoTask.this.onStart();
|
||
Log.i("启动录制:" + playInfo.getRoomId());
|
||
task = null;
|
||
|
||
cancel();
|
||
}
|
||
};
|
||
new Timer().schedule(task, 5 * 1000);
|
||
}
|
||
|
||
@Override
|
||
public boolean onDownloading(double soFarBytes, double totalBytes) {
|
||
return super.onDownloading(soFarBytes, totalBytes);
|
||
}
|
||
|
||
@Override
|
||
public void onDownload(File file) {
|
||
super.onDownload(file);
|
||
if (task != null) {
|
||
task.cancel();
|
||
task = null;
|
||
try {
|
||
FileUtils.deleteDirectory(rootPath);
|
||
} catch (IOException e) {
|
||
Log.i(rootPath.getAbsolutePath());
|
||
Log.e(e);
|
||
}
|
||
}
|
||
if (videoDatabaseBean != null) {
|
||
videoDatabaseBean.setStopTime(new Date());
|
||
liveDatabasesService.getLiveDatabase(bean.getRoomId()).addLiveInfo(videoDatabaseBean);
|
||
}
|
||
stopRecordDanmu();
|
||
}
|
||
});
|
||
|
||
} catch (Exception e) {
|
||
throw new RuntimeException(e);
|
||
}
|
||
|
||
}
|
||
|
||
private void onStart() {
|
||
videoDatabaseBean = new LiveVideoDatabaseBean();
|
||
videoDatabaseBean.setPath(savePath);
|
||
videoDatabaseBean.setRoomInfoJson(JSONObject.toJSONString(roomInfo));
|
||
videoDatabaseBean.setStartTime(new Date());
|
||
liveDatabasesService.getLiveDatabase(bean.getRoomId()).addLiveInfo(videoDatabaseBean);
|
||
recordDanmu();
|
||
// LiveInfoNfoTools.saveLiveInfoNfo(roomInfo, rootPath.getAbsolutePath(), new File(savePath).getName().replace(".flv", ".nfo"));
|
||
}
|
||
|
||
//录制弹幕
|
||
private void recordDanmu() {
|
||
if (bean.isSyncDanmuForLive() && !webSocketServer.checkRoom(liveDatabasesService.buildConfig(bean.getRoomId()))) {
|
||
webSocketServer.addRoom(liveDatabasesService.buildConfig(bean.getRoomId()), true);
|
||
}
|
||
}
|
||
|
||
private void stopRecordDanmu() {
|
||
if (bean.isSyncDanmuForLive() && webSocketServer.checkRoom(liveDatabasesService.buildConfig(bean.getRoomId()))) {
|
||
webSocketServer.stopRoom(bean.getRoomId(), false);
|
||
}
|
||
}
|
||
}
|
||
|
||
private void saveLiveInfo(LiveRoomInfo roomInfo) {
|
||
|
||
}
|
||
|
||
public VideoFilePath getVideoPath(String roomId) {
|
||
LiveConfigDatabaseBean bean = liveDatabasesService.getConfigDatabase().getConfig(roomId);
|
||
return getVideoFilePath(bean);
|
||
}
|
||
|
||
private VideoFilePath getVideoFilePath(LiveConfigDatabaseBean configBean) {
|
||
String recordPath = configBean.getRecordPath() + File.separator + configBean.getAnchorName();
|
||
File recordDir = new File(recordPath);
|
||
VideoFilePath path = createVideoRootFilePath(configBean, recordDir);
|
||
if (recordDir.exists()) {
|
||
List<LiveVideoDatabaseBean> infos = liveDatabasesService.getLiveDatabase(configBean.getRoomId()).getLiveInfos();
|
||
path.setChildren(getVideoInfo(infos));
|
||
}
|
||
return path;
|
||
}
|
||
|
||
private VideoFilePath createVideoRootFilePath(LiveConfigDatabaseBean config, File db) {
|
||
VideoFilePath path = new VideoFilePath();
|
||
path.setRoomId(config.getRoomId());
|
||
path.setCover(config.getAnchorFace());
|
||
path.setName(config.getAnchorName());
|
||
path.setUid(config.getAnchorUid());
|
||
path.setParent(true);
|
||
path.setPath(FileServerUtils.toUrl(db.getParent()));
|
||
return path;
|
||
}
|
||
|
||
private Map<String, List<VideoFilePath>> getVideoInfo(List<LiveVideoDatabaseBean> videoList) {
|
||
Map<String, List<VideoFilePath>> map = new HashMap<>();
|
||
for (LiveVideoDatabaseBean bean : videoList) {
|
||
String date = DateFormatUtils.getInstance().format(bean.getSql_time(), "yyyy-MM-dd");
|
||
if (!map.containsKey(date)) {
|
||
map.put(date, new ArrayList<>());
|
||
}
|
||
VideoFilePath path = new VideoFilePath();
|
||
LiveRoomInfo roomInfo = JSONObject.parseObject(bean.getRoomInfoJson(), LiveRoomInfo.class);
|
||
path.setRoomId(roomInfo.getRoomId());
|
||
path.setName(roomInfo.getTitle());
|
||
path.setUid(roomInfo.getUid());
|
||
path.setPath(String.valueOf(bean.getSql_time().getTime()));
|
||
path.setCover(roomInfo.getKeyframe());
|
||
path.setParent(false);
|
||
path.setChildren(null);
|
||
map.get(date).add(path);
|
||
}
|
||
return map;
|
||
}
|
||
|
||
public String getVideoPlay(String roomId, String videoId) {
|
||
String ffmpegPath = ConfigTools.load(ConfigTools.CONFIG, "ffmpeg", String.class);
|
||
LiveConfigDatabaseBean config = liveDatabasesService.getConfigDatabase().getConfig(roomId);
|
||
String recordPath = config.getRecordPath() + File.separator + config.getAnchorName();
|
||
LiveVideoDatabaseBean videoInfo = null;
|
||
for (LiveVideoDatabaseBean info : liveDatabasesService.getLiveDatabase(roomId).getLiveInfos()) {
|
||
if (videoId.trim().equals(String.valueOf(info.getSql_time().getTime()))) {
|
||
videoInfo = info;
|
||
break;
|
||
}
|
||
}
|
||
if (videoInfo != null) {
|
||
File videoFile = new File(videoInfo.getPath().replace("-%04d.ts", ".m3u8"));
|
||
if (!videoFile.exists()) {
|
||
videoFile = new File(videoInfo.getPath());
|
||
} else {
|
||
return videoInfo.getPath().replace(new File("live").getAbsolutePath(), "").replace(File.separator, "/").replace("-%04d.ts", ".m3u8");
|
||
}
|
||
FFmpegUtils ffmpeg = FFmpegUtils.segment(videoId, ffmpegPath, videoFile, ConfigTools.load(ConfigTools.CONFIG, "outVideoPath", String.class));
|
||
System.out.println(ffmpeg.getCommandDecode());
|
||
ffmpeg.start(new DownloadInterface() {
|
||
@Override
|
||
public void onDownload(File file) {
|
||
super.onDownload(file);
|
||
|
||
}
|
||
});
|
||
return ffmpeg.getOutputFilePath();
|
||
}
|
||
return null;
|
||
}
|
||
|
||
public static void main(String[] args) {
|
||
LiveVideoDownloadService service = new LiveVideoDownloadService();
|
||
String play = service.getVideoPlay("17961", "1730363029293");
|
||
System.out.println(play);
|
||
}
|
||
}
|