fix: docker action

* 插件数据库不同时，新建DB 对象赋值给插件

* MP4 plugin adds extraction, clips, images, compressed video, GOP clicp

* remove mp4/util panic code

.github/workflows/go.yml

@@ -93,9 +93,16 @@ jobs:
         tar -zxvf bin/m7s_v5_linux_arm64.tar.gz
         mv m7s monibuca_arm64
         docker login -u langhuihui -p ${{ secrets.DOCKER_PASSWORD }}
-        docker buildx build --platform linux/amd64,linux/arm64 -t langhuihui/monibuca:v5 --push .
-    - name: docker push version tag
-      if: success() && !contains(env.version, 'beta')
+        if [[ "${{ env.version }}" == *"beta"* ]]; then
+          docker buildx build --platform linux/amd64,linux/arm64 -t langhuihui/monibuca:v5 --push .
+        else
+          docker buildx build --platform linux/amd64,linux/arm64 -t langhuihui/monibuca:v5 -t langhuihui/monibuca:${{ env.version }} --push .
+        fi
+    - name: docker build lite version
+      if: success() && startsWith(github.ref, 'refs/tags/')
       run:  |
-        docker tag langhuihui/monibuca:v5 langhuihui/monibuca:${{ env.version }}
-        docker push langhuihui/monibuca:${{ env.version }}
+        if [[ "${{ env.version }}" == *"beta"* ]]; then
+          docker buildx build --platform linux/amd64,linux/arm64 -f DockerfileLite -t monibuca/v5:latest --push .
+        else
+          docker buildx build --platform linux/amd64,linux/arm64 -f DockerfileLite -t monibuca/v5:latest -t monibuca/v5:${{ env.version }} --push .
+        fi

DockerfileLite

@@ -0,0 +1,31 @@
+# Running Stage 
+FROM alpine:latest
+
+WORKDIR /monibuca 
+
+# Copy the pre-compiled binary from the build context
+# The GitHub Actions workflow prepares 'monibuca_linux' in the context root
+
+COPY monibuca_amd64 ./monibuca_amd64
+COPY monibuca_arm64 ./monibuca_arm64
+
+COPY admin.zip ./admin.zip
+
+# Copy the configuration file from the build context
+COPY example/default/config.yaml /etc/monibuca/config.yaml
+
+# Export necessary ports 
+EXPOSE 6000 8080 8443 1935 554 5060 9000-20000
+EXPOSE 5060/udp 44944/udp
+
+RUN if [ "$(uname -m)" = "aarch64" ]; then \
+      mv ./monibuca_arm64 ./monibuca_linux; \
+      rm ./monibuca_amd64; \
+    else \
+      mv ./monibuca_amd64 ./monibuca_linux; \
+      rm ./monibuca_arm64; \
+    fi
+
+
+ENTRYPOINT [ "./monibuca_linux"]
+CMD ["-c", "/etc/monibuca/config.yaml"]

RELEASE_NOTES_5.0.x_CN.md

@@ -0,0 +1,139 @@
+# Monibuca v5.0.x Release Notes
+
+## v5.0.3 (2025-06-27)
+
+### 🎉 新功能 (New Features)
+
+#### 录像与流媒体协议增强
+- **MP4/FLV录像优化**：多项修复和优化录像拉取、分片、写入、格式转换等功能，提升兼容性和稳定性。
+- **GB28181协议增强**：支持pullproxy代理GB28181流，完善平台配置、子码流播放、单独media port等能力。
+- **插件与配置系统**：插件初始化、配置加载、数据库适配等增强，支持获取全部配置yaml示例。
+- **WebRTC/HLS/RTMP协议适配**：WebRTC支持更多编解码器，HLS/RTMP协议兼容性提升。
+- **crontab计划录像**：定时任务插件支持计划录像，拉流代理支持禁用。
+
+### 🐛 问题修复 (Bug Fixes)
+- **录像/流媒体相关**：修复mp4、flv、rtmp、hls等协议的多项bug，包括clone buffer、SQL语法、表结构适配等。
+- **GB28181/数据库**：修复注册、流订阅、表结构、SQL语法等问题，适配PostgreSQL。
+- **插件系统**：修复插件初始化、数据库对象赋值、配置加载等问题。
+
+### 🛠️ 优化改进 (Improvements)
+- **代码结构重构**：重构mp4、record、插件等系统，提升可维护性。
+- **文档与示例**：完善文档说明，增加配置和API示例。
+- **Docker镜像**：优化tcpdump、ffmpeg等工具集成。
+
+### 👥 贡献者 (Contributors)
+- langhuihui
+- pggiroro
+- banshan
+
+---
+
+## v5.0.2 (2025-06-05)
+
+### 🎉 新功能 (New Features)
+
+#### 核心功能
+- **降低延迟** - 禁用了TCP WebRTC的重放保护功能，降低了延迟
+- **配置系统增强** - 支持更多配置格式（支持配置项中插入`-`、`_`和大写字母），提升配置灵活性
+- **原始数据检查** - 新增原始数据无帧检查功能，提升数据处理稳定性
+- **MP4循环读取** - 支持MP4文件循环读取功能（通过配置 pull 配置下的 `loop` 配置）
+- **S3插件** - 新增S3存储插件，支持云存储集成
+- **TCP读写缓冲配置** - 新增TCP连接读写缓冲区配置选项（针对高并发下的吞吐能力增强）
+- **拉流测试模式** - 新增拉流测试模式选项（可以选择拉流时不发布），便于调试和测试
+- **SEI API格式扩展** - 扩展SEI API支持更多数据格式
+- **Hook扩展** - 新增更多Hook回调点，增强扩展性
+- **定时任务插件** - 新增crontab定时任务插件
+- **服务器抓包** - 新增服务器抓包功能（调用`tcpdump`），支持TCP和UDP协议,API 说明见 [tcpdump](https://api.monibuca.com/api-301117332)
+
+#### GB28181协议增强
+- **平台配置支持** - GB28181现在支持从config.yaml中添加平台和平台通道配置
+- **子码流播放** - 支持GB28181子码流播放功能
+- **SDP优化** - 优化invite SDP中的mediaip和sipip处理
+- **本地端口保存** - 修复GB28181本地端口保存到数据库的问题
+
+#### MP4功能增强
+- **FLV格式下载** - 支持从MP4录制文件下载FLV格式
+- **下载功能修复** - 修复MP4下载功能的相关问题
+- **恢复功能修复** - 修复MP4恢复功能
+
+### 🐛 问题修复 (Bug Fixes)
+
+#### 网络通信
+- **TCP读取阻塞** - 修复TCP读取阻塞问题（增加了读取超时设置）
+- **RTSP内存泄漏** - 修复RTSP协议的内存泄漏问题
+- **RTSP音视频标识** - 修复RTSP无音频或视频标识的问题
+
+#### GB28181协议
+- **任务管理** - 使用task.Manager解决注册处理器的问题
+- **计划长度** - 修复plan.length为168的问题
+- **注册频率** - 修复GB28181注册过快导致启动过多任务的问题
+- **联系信息** - 修复GB28181获取错误联系信息的问题
+
+#### RTMP协议
+- **时间戳处理** - 修复RTMP时间戳开头跳跃问题
+
+### 🛠️ 优化改进 (Improvements)
+
+#### Docker支持
+- **tcpdump工具** - Docker镜像中新增tcpdump网络诊断工具
+
+#### Linux平台优化
+- **SIP请求优化** - Linux平台移除SIP请求中的viaheader
+
+### 👥 贡献者 (Contributors)
+- langhuihui
+- pggiroro  
+- banshan
+
+---
+
+## v5.0.1 (2025-05-21)
+
+### 🎉 新功能 (New Features)
+
+#### WebRTC增强
+- **H265支持** - 新增WebRTC对H265编码的支持，提升视频质量和压缩效率
+
+#### GB28181协议增强
+- **订阅功能扩展** - GB28181模块现在支持订阅报警、移动位置、目录信息
+- **通知请求** - 支持接收通知请求，增强与设备的交互能力
+
+#### Docker优化
+- **FFmpeg集成** - Docker镜像中新增FFmpeg工具，支持更多音视频处理场景
+- **多架构支持** - 新增Docker多架构构建支持
+
+### 🐛 问题修复 (Bug Fixes)
+
+#### Docker相关
+- **构建问题** - 修复Docker构建过程中的多个问题
+- **构建优化** - 优化Docker构建流程，提升构建效率
+
+#### RTMP协议
+- **时间戳处理** - 修复RTMP第一个chunk类型3需要添加时间戳的问题
+
+#### GB28181协议  
+- **路径匹配** - 修复GB28181模块中播放流路径的正则表达式匹配问题
+
+#### MP4处理
+- **stsz box** - 修复stsz box采样大小的问题
+- **G711音频** - 修复拉取MP4文件时读取G711音频的问题
+- **H265解析** - 修复H265 MP4文件解析问题
+
+### 🛠️ 优化改进 (Improvements)
+
+#### 代码质量
+- **错误处理** - 新增maxcount错误处理机制
+- **文档更新** - 更新README文档和go.mod配置
+
+#### 构建系统
+- **ARM架构** - 减少JavaScript代码，优化ARM架构Docker构建
+- **构建标签** - 移除Docker中不必要的构建标签
+
+### 📦 其他更新 (Other Updates)
+- **MCP相关** - 更新Model Context Protocol相关功能
+- **依赖更新** - 更新项目依赖和模块配置
+
+### 👥 贡献者 (Contributors)
+- langhuihui
+
+---

api.go

@@ -96,22 +96,14 @@ func (s *Server) api_Stream_AnnexB_(rw http.ResponseWriter, r *http.Request) {
 		return
 	}
 	defer reader.StopRead()
-	if reader.Value.Raw == nil {
-		if err = reader.Value.Demux(publisher.VideoTrack.ICodecCtx); err != nil {
-			http.Error(rw, err.Error(), http.StatusInternalServerError)
-			return
-		}
-	}
-	var annexb pkg.AnnexB
-	var t pkg.AVTrack
-
-	t.ICodecCtx, t.SequenceFrame, err = annexb.ConvertCtx(publisher.VideoTrack.ICodecCtx)
-	if t.ICodecCtx == nil {
-		http.Error(rw, "unsupported codec", http.StatusInternalServerError)
+	var annexb *pkg.AnnexB
+	var converter = pkg.NewAVFrameConvert[*pkg.AnnexB](publisher.VideoTrack.AVTrack, nil)
+	annexb, err = converter.ConvertFromAVFrame(&reader.Value)
+	if err != nil {
+		http.Error(rw, err.Error(), http.StatusInternalServerError)
 		return
 	}
-	annexb.Mux(t.ICodecCtx, &reader.Value)
-	_, err = annexb.WriteTo(rw)
+	annexb.WriteTo(rw)
 }
 
 func (s *Server) getStreamInfo(pub *Publisher) (res *pb.StreamInfoResponse, err error) {
@@ -180,19 +172,17 @@ func (s *Server) getStreamInfo(pub *Publisher) (res *pb.StreamInfoResponse, err
 
 func (s *Server) StreamInfo(ctx context.Context, req *pb.StreamSnapRequest) (res *pb.StreamInfoResponse, err error) {
 	var recordings []*pb.RecordingDetail
-	s.Records.Call(func() error {
-		for record := range s.Records.Range {
-			if record.StreamPath == req.StreamPath {
-				recordings = append(recordings, &pb.RecordingDetail{
-					FilePath:   record.RecConf.FilePath,
-					Mode:       record.Mode,
-					Fragment:   durationpb.New(record.RecConf.Fragment),
-					Append:     record.RecConf.Append,
-					PluginName: record.Plugin.Meta.Name,
-				})
-			}
+	s.Records.SafeRange(func(record *RecordJob) bool {
+		if record.StreamPath == req.StreamPath {
+			recordings = append(recordings, &pb.RecordingDetail{
+				FilePath:   record.RecConf.FilePath,
+				Mode:       record.RecConf.Mode,
+				Fragment:   durationpb.New(record.RecConf.Fragment),
+				Append:     record.RecConf.Append,
+				PluginName: record.Plugin.Meta.Name,
+			})
 		}
-		return nil
+		return true
 	})
 	if pub, ok := s.Streams.SafeGet(req.StreamPath); ok {
 		res, err = s.getStreamInfo(pub)
@@ -260,17 +250,15 @@ func (s *Server) RestartTask(ctx context.Context, req *pb.RequestWithId64) (resp
 }
 
 func (s *Server) GetRecording(ctx context.Context, req *emptypb.Empty) (resp *pb.RecordingListResponse, err error) {
-	s.Records.Call(func() error {
-		resp = &pb.RecordingListResponse{}
-		for record := range s.Records.Range {
-			resp.Data = append(resp.Data, &pb.Recording{
-				StreamPath: record.StreamPath,
-				StartTime:  timestamppb.New(record.StartTime),
-				Type:       reflect.TypeOf(record.recorder).String(),
-				Pointer:    uint64(record.GetTaskPointer()),
-			})
-		}
-		return nil
+	resp = &pb.RecordingListResponse{}
+	s.Records.SafeRange(func(record *RecordJob) bool {
+		resp.Data = append(resp.Data, &pb.Recording{
+			StreamPath: record.StreamPath,
+			StartTime:  timestamppb.New(record.StartTime),
+			Type:       reflect.TypeOf(record.recorder).String(),
+			Pointer:    uint64(record.GetTaskPointer()),
+		})
+		return true
 	})
 	return
 }
@@ -490,7 +478,7 @@ func (s *Server) Shutdown(ctx context.Context, req *pb.RequestWithId) (res *pb.S
 func (s *Server) ChangeSubscribe(ctx context.Context, req *pb.ChangeSubscribeRequest) (res *pb.SuccessResponse, err error) {
 	s.Streams.Call(func() error {
 		if subscriber, ok := s.Subscribers.Get(req.Id); ok {
-			if pub, ok := s.Streams.SafeGet(req.StreamPath); ok {
+			if pub, ok := s.Streams.Get(req.StreamPath); ok {
 				subscriber.Publisher.RemoveSubscriber(subscriber)
 				subscriber.StreamPath = req.StreamPath
 				pub.AddSubscriber(subscriber)
@@ -516,86 +504,65 @@ func (s *Server) StopSubscribe(ctx context.Context, req *pb.RequestWithId) (res
 }
 
 func (s *Server) PauseStream(ctx context.Context, req *pb.StreamSnapRequest) (res *pb.SuccessResponse, err error) {
-	s.Streams.Call(func() error {
-		if s, ok := s.Streams.SafeGet(req.StreamPath); ok {
-			s.Pause()
-		}
-		return nil
-	})
+	if s, ok := s.Streams.SafeGet(req.StreamPath); ok {
+		s.Pause()
+	}
 	return &pb.SuccessResponse{}, err
 }
 
 func (s *Server) ResumeStream(ctx context.Context, req *pb.StreamSnapRequest) (res *pb.SuccessResponse, err error) {
-	s.Streams.Call(func() error {
-		if s, ok := s.Streams.SafeGet(req.StreamPath); ok {
-			s.Resume()
-		}
-		return nil
-	})
+	if s, ok := s.Streams.SafeGet(req.StreamPath); ok {
+		s.Resume()
+	}
 	return &pb.SuccessResponse{}, err
 }
 
 func (s *Server) SetStreamSpeed(ctx context.Context, req *pb.SetStreamSpeedRequest) (res *pb.SuccessResponse, err error) {
-	s.Streams.Call(func() error {
-		if s, ok := s.Streams.SafeGet(req.StreamPath); ok {
-			s.Speed = float64(req.Speed)
-			s.Scale = float64(req.Speed)
-			s.Info("set stream speed", "speed", req.Speed)
-		}
-		return nil
-	})
+	if s, ok := s.Streams.SafeGet(req.StreamPath); ok {
+		s.Speed = float64(req.Speed)
+		s.Scale = float64(req.Speed)
+		s.Info("set stream speed", "speed", req.Speed)
+	}
 	return &pb.SuccessResponse{}, err
 }
 
 func (s *Server) SeekStream(ctx context.Context, req *pb.SeekStreamRequest) (res *pb.SuccessResponse, err error) {
-	s.Streams.Call(func() error {
-		if s, ok := s.Streams.SafeGet(req.StreamPath); ok {
-			s.Seek(time.Unix(int64(req.TimeStamp), 0))
-		}
-		return nil
-	})
+	if s, ok := s.Streams.SafeGet(req.StreamPath); ok {
+		s.Seek(time.Unix(int64(req.TimeStamp), 0))
+	}
 	return &pb.SuccessResponse{}, err
 }
 
 func (s *Server) StopPublish(ctx context.Context, req *pb.StreamSnapRequest) (res *pb.SuccessResponse, err error) {
-	s.Streams.Call(func() error {
-		if s, ok := s.Streams.SafeGet(req.StreamPath); ok {
-			s.Stop(task.ErrStopByUser)
-		}
-		return nil
-	})
+	if s, ok := s.Streams.SafeGet(req.StreamPath); ok {
+		s.Stop(task.ErrStopByUser)
+	}
 	return &pb.SuccessResponse{}, err
 }
 
 // /api/stream/list
 func (s *Server) StreamList(_ context.Context, req *pb.StreamListRequest) (res *pb.StreamListResponse, err error) {
 	recordingMap := make(map[string][]*pb.RecordingDetail)
-	s.Records.Call(func() error {
-		for record := range s.Records.Range {
-			recordingMap[record.StreamPath] = append(recordingMap[record.StreamPath], &pb.RecordingDetail{
-				FilePath:   record.RecConf.FilePath,
-				Mode:       record.Mode,
-				Fragment:   durationpb.New(record.RecConf.Fragment),
-				Append:     record.RecConf.Append,
-				PluginName: record.Plugin.Meta.Name,
-				Pointer:    uint64(record.GetTaskPointer()),
-			})
+	for record := range s.Records.SafeRange {
+		recordingMap[record.StreamPath] = append(recordingMap[record.StreamPath], &pb.RecordingDetail{
+			FilePath:   record.RecConf.FilePath,
+			Mode:       record.RecConf.Mode,
+			Fragment:   durationpb.New(record.RecConf.Fragment),
+			Append:     record.RecConf.Append,
+			PluginName: record.Plugin.Meta.Name,
+			Pointer:    uint64(record.GetTaskPointer()),
+		})
+	}
+	var streams []*pb.StreamInfo
+	for publisher := range s.Streams.SafeRange {
+		info, err := s.getStreamInfo(publisher)
+		if err != nil {
+			continue
 		}
-		return nil
-	})
-	s.Streams.Call(func() error {
-		var streams []*pb.StreamInfo
-		for publisher := range s.Streams.Range {
-			info, err := s.getStreamInfo(publisher)
-			if err != nil {
-				continue
-			}
-			info.Data.Recording = recordingMap[info.Data.Path]
-			streams = append(streams, info.Data)
-		}
-		res = &pb.StreamListResponse{Data: streams, Total: int32(s.Streams.Length), PageNum: req.PageNum, PageSize: req.PageSize}
-		return nil
-	})
+		info.Data.Recording = recordingMap[info.Data.Path]
+		streams = append(streams, info.Data)
+	}
+	res = &pb.StreamListResponse{Data: streams, Total: int32(s.Streams.Length), PageNum: req.PageNum, PageSize: req.PageSize}
 	return
 }
 
@@ -761,7 +728,7 @@ func (s *Server) GetConfig(_ context.Context, req *pb.GetConfigRequest) (res *pb
 	return
 }
 
-func (s *Server) GetRecordList(ctx context.Context, req *pb.ReqRecordList) (resp *pb.ResponseList, err error) {
+func (s *Server) GetRecordList(ctx context.Context, req *pb.ReqRecordList) (resp *pb.RecordResponseList, err error) {
 	if s.DB == nil {
 		err = pkg.ErrNoDB
 		return
@@ -782,8 +749,61 @@ func (s *Server) GetRecordList(ctx context.Context, req *pb.ReqRecordList) (resp
 	} else if req.StreamPath != "" {
 		query = query.Where("stream_path = ?", req.StreamPath)
 	}
-	if req.Mode != "" {
-		query = query.Where("mode = ?", req.Mode)
+	if req.Type != "" {
+		query = query.Where("type = ?", req.Type)
+	}
+	startTime, endTime, err := util.TimeRangeQueryParse(url.Values{"range": []string{req.Range}, "start": []string{req.Start}, "end": []string{req.End}})
+	if err == nil {
+		if !startTime.IsZero() {
+			query = query.Where("start_time >= ?", startTime)
+		}
+		if !endTime.IsZero() {
+			query = query.Where("end_time <= ?", endTime)
+		}
+	}
+
+	query.Count(&totalCount)
+	err = query.Offset(int(offset)).Limit(int(req.PageSize)).Order("start_time desc").Find(&result).Error
+	if err != nil {
+		return
+	}
+	resp = &pb.RecordResponseList{
+		Total:    uint32(totalCount),
+		PageNum:  req.PageNum,
+		PageSize: req.PageSize,
+	}
+	for _, recordFile := range result {
+		resp.Data = append(resp.Data, &pb.RecordFile{
+			Id:         uint32(recordFile.ID),
+			StartTime:  timestamppb.New(recordFile.StartTime),
+			EndTime:    timestamppb.New(recordFile.EndTime),
+			FilePath:   recordFile.FilePath,
+			StreamPath: recordFile.StreamPath,
+		})
+	}
+	return
+}
+
+func (s *Server) GetEventRecordList(ctx context.Context, req *pb.ReqRecordList) (resp *pb.EventRecordResponseList, err error) {
+	if s.DB == nil {
+		err = pkg.ErrNoDB
+		return
+	}
+	if req.PageSize == 0 {
+		req.PageSize = 10
+	}
+	if req.PageNum == 0 {
+		req.PageNum = 1
+	}
+	offset := (req.PageNum - 1) * req.PageSize // 计算偏移量
+	var totalCount int64                       //总条数
+
+	var result []*EventRecordStream
+	query := s.DB.Model(&EventRecordStream{})
+	if strings.Contains(req.StreamPath, "*") {
+		query = query.Where("stream_path like ?", strings.ReplaceAll(req.StreamPath, "*", "%"))
+	} else if req.StreamPath != "" {
+		query = query.Where("stream_path = ?", req.StreamPath)
 	}
 	if req.Type != "" {
 		query = query.Where("type = ?", req.Type)
@@ -806,21 +826,22 @@ func (s *Server) GetRecordList(ctx context.Context, req *pb.ReqRecordList) (resp
 	if err != nil {
 		return
 	}
-	resp = &pb.ResponseList{
+	resp = &pb.EventRecordResponseList{
 		Total:    uint32(totalCount),
 		PageNum:  req.PageNum,
 		PageSize: req.PageSize,
 	}
 	for _, recordFile := range result {
-		resp.Data = append(resp.Data, &pb.RecordFile{
+		resp.Data = append(resp.Data, &pb.EventRecordFile{
 			Id:         uint32(recordFile.ID),
 			StartTime:  timestamppb.New(recordFile.StartTime),
 			EndTime:    timestamppb.New(recordFile.EndTime),
 			FilePath:   recordFile.FilePath,
 			StreamPath: recordFile.StreamPath,
 			EventLevel: recordFile.EventLevel,
-			EventDesc:  recordFile.EventDesc,
+			EventId:    recordFile.EventId,
 			EventName:  recordFile.EventName,
+			EventDesc:  recordFile.EventDesc,
 		})
 	}
 	return

api_config.go

@@ -0,0 +1,324 @@
+package m7s
+
+import (
+	"net/http"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+
+	"gopkg.in/yaml.v3"
+)
+
+func getIndent(line string) int {
+	return len(line) - len(strings.TrimLeft(line, " "))
+}
+
+func addCommentsToYAML(yamlData []byte) []byte {
+	lines := strings.Split(string(yamlData), "\n")
+	var result strings.Builder
+	var commentBuffer []string
+	var keyLineBuffer string
+	var keyLineIndent int
+	inMultilineValue := false
+
+	for _, line := range lines {
+		trimmedLine := strings.TrimSpace(line)
+		indent := getIndent(line)
+
+		if strings.HasPrefix(trimmedLine, "_description:") {
+			description := strings.TrimSpace(strings.TrimPrefix(trimmedLine, "_description:"))
+			commentBuffer = append(commentBuffer, "# "+description)
+		} else if strings.HasPrefix(trimmedLine, "_enum:") {
+			enum := strings.TrimSpace(strings.TrimPrefix(trimmedLine, "_enum:"))
+			commentBuffer = append(commentBuffer, "# 可选值: "+enum)
+		} else if strings.HasPrefix(trimmedLine, "_value:") {
+			valueStr := strings.TrimSpace(strings.TrimPrefix(trimmedLine, "_value:"))
+			if valueStr != "" && valueStr != "{}" && valueStr != "[]" {
+				// Single line value
+				result.WriteString(strings.Repeat(" ", keyLineIndent))
+				result.WriteString(keyLineBuffer)
+				result.WriteString(": ")
+				result.WriteString(valueStr)
+				if len(commentBuffer) > 0 {
+					result.WriteString(" ")
+					for j, c := range commentBuffer {
+						c = strings.TrimSpace(strings.TrimPrefix(c, "#"))
+						result.WriteString("# " + c)
+						if j < len(commentBuffer)-1 {
+							result.WriteString(" ")
+						}
+					}
+				}
+				result.WriteString("\n")
+			} else {
+				// Multi-line value (struct/map)
+				for _, comment := range commentBuffer {
+					result.WriteString(strings.Repeat(" ", keyLineIndent))
+					result.WriteString(comment)
+					result.WriteString("\n")
+				}
+				result.WriteString(strings.Repeat(" ", keyLineIndent))
+				result.WriteString(keyLineBuffer)
+				result.WriteString(":")
+				result.WriteString("\n")
+				inMultilineValue = true
+			}
+			commentBuffer = nil
+			keyLineBuffer = ""
+			keyLineIndent = 0
+		} else if strings.Contains(trimmedLine, ":") {
+			// This is a key line
+			if keyLineBuffer != "" { // flush previous key line
+				result.WriteString(strings.Repeat(" ", keyLineIndent) + keyLineBuffer + ":\n")
+			}
+			inMultilineValue = false
+			keyLineBuffer = strings.TrimSuffix(trimmedLine, ":")
+			keyLineIndent = indent
+		} else if inMultilineValue {
+			// These are the lines of a multiline value
+			if trimmedLine != "" {
+				result.WriteString(line + "\n")
+			}
+		}
+	}
+	if keyLineBuffer != "" {
+		result.WriteString(strings.Repeat(" ", keyLineIndent) + keyLineBuffer + ":\n")
+	}
+
+	// Final cleanup to remove empty lines and special keys
+	finalOutput := []string{}
+	for _, line := range strings.Split(result.String(), "\n") {
+		trimmed := strings.TrimSpace(line)
+		if trimmed == "" || strings.HasPrefix(trimmed, "_") {
+			continue
+		}
+		finalOutput = append(finalOutput, line)
+	}
+
+	return []byte(strings.Join(finalOutput, "\n"))
+}
+
+func (s *Server) api_Config_YAML_All(rw http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	filterName := query.Get("name")
+	shouldMergeCommon := query.Get("common") != "false"
+
+	configSections := []struct {
+		name string
+		data any
+	}{}
+
+	// 1. Get common config if it needs to be merged.
+	var commonConfig map[string]any
+	if shouldMergeCommon {
+		if c, ok := extractStructConfig(reflect.ValueOf(s.Plugin.GetCommonConf())).(map[string]any); ok {
+			commonConfig = c
+		}
+	}
+
+	// 2. Process global config.
+	if filterName == "" || filterName == "global" {
+		if globalConf, ok := extractStructConfig(reflect.ValueOf(s.ServerConfig)).(map[string]any); ok {
+			if shouldMergeCommon && commonConfig != nil {
+				mergedConf := make(map[string]any)
+				for k, v := range commonConfig {
+					mergedConf[k] = v
+				}
+				for k, v := range globalConf {
+					mergedConf[k] = v // Global overrides common
+				}
+				configSections = append(configSections, struct {
+					name string
+					data any
+				}{"global", mergedConf})
+			} else {
+				configSections = append(configSections, struct {
+					name string
+					data any
+				}{"global", globalConf})
+			}
+		}
+	}
+
+	// 3. Process plugin configs.
+	for _, meta := range plugins {
+		if filterName != "" && meta.Name != filterName {
+			continue
+		}
+
+		configType := meta.Type
+		if configType.Kind() == reflect.Ptr {
+			configType = configType.Elem()
+		}
+
+		if pluginConf, ok := extractStructConfig(reflect.New(configType)).(map[string]any); ok {
+			pluginConf["enable"] = map[string]any{
+				"_value":       true,
+				"_description": "在global配置disableall时能启用特定插件",
+			}
+			if shouldMergeCommon && commonConfig != nil {
+				mergedConf := make(map[string]any)
+				for k, v := range commonConfig {
+					mergedConf[k] = v
+				}
+				for k, v := range pluginConf {
+					mergedConf[k] = v // Plugin overrides common
+				}
+				configSections = append(configSections, struct {
+					name string
+					data any
+				}{meta.Name, mergedConf})
+			} else {
+				configSections = append(configSections, struct {
+					name string
+					data any
+				}{meta.Name, pluginConf})
+			}
+		}
+	}
+
+	// 4. Serialize each section and combine.
+	var yamlParts []string
+	for _, section := range configSections {
+		if section.data == nil {
+			continue
+		}
+		partMap := map[string]any{section.name: section.data}
+		partYAML, err := yaml.Marshal(partMap)
+		if err != nil {
+			http.Error(rw, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		yamlParts = append(yamlParts, string(partYAML))
+	}
+
+	finalYAML := strings.Join(yamlParts, "")
+
+	rw.Header().Set("Content-Type", "text/yaml; charset=utf-8")
+	rw.Write(addCommentsToYAML([]byte(finalYAML)))
+}
+
+func extractStructConfig(v reflect.Value) any {
+	if v.Kind() == reflect.Ptr {
+		if v.IsNil() {
+			return nil
+		}
+		v = v.Elem()
+	}
+	if v.Kind() != reflect.Struct {
+		return nil
+	}
+	m := make(map[string]any)
+	for i := 0; i < v.NumField(); i++ {
+		field := v.Type().Field(i)
+		if !field.IsExported() {
+			continue
+		}
+		// Filter out Plugin and UnimplementedApiServer
+		fieldType := field.Type
+		if fieldType.Kind() == reflect.Ptr {
+			fieldType = fieldType.Elem()
+		}
+		if fieldType.Name() == "Plugin" || fieldType.Name() == "UnimplementedApiServer" {
+			continue
+		}
+		yamlTag := field.Tag.Get("yaml")
+		if yamlTag == "-" {
+			continue
+		}
+		fieldName := strings.Split(yamlTag, ",")[0]
+		if fieldName == "" {
+			fieldName = strings.ToLower(field.Name)
+		}
+		m[fieldName] = extractFieldConfig(field, v.Field(i))
+	}
+	return m
+}
+
+func extractFieldConfig(field reflect.StructField, value reflect.Value) any {
+	result := make(map[string]any)
+	description := field.Tag.Get("desc")
+	enum := field.Tag.Get("enum")
+	if description != "" {
+		result["_description"] = description
+	}
+	if enum != "" {
+		result["_enum"] = enum
+	}
+
+	kind := value.Kind()
+	if kind == reflect.Ptr {
+		if value.IsNil() {
+			value = reflect.New(value.Type().Elem())
+		}
+		value = value.Elem()
+		kind = value.Kind()
+	}
+
+	switch kind {
+	case reflect.Struct:
+		if dur, ok := value.Interface().(time.Duration); ok {
+			result["_value"] = extractDurationConfig(field, dur)
+		} else {
+			result["_value"] = extractStructConfig(value)
+		}
+	case reflect.Map, reflect.Slice:
+		if value.IsNil() {
+			result["_value"] = make(map[string]any)
+			if kind == reflect.Slice {
+				result["_value"] = make([]any, 0)
+			}
+		} else {
+			result["_value"] = value.Interface()
+		}
+	default:
+		result["_value"] = extractBasicTypeConfig(field, value)
+	}
+
+	if description == "" && enum == "" {
+		return result["_value"]
+	}
+
+	return result
+}
+
+func extractBasicTypeConfig(field reflect.StructField, value reflect.Value) any {
+	if value.IsZero() {
+		if defaultValue := field.Tag.Get("default"); defaultValue != "" {
+			return parseDefaultValue(defaultValue, field.Type)
+		}
+	}
+	return value.Interface()
+}
+
+func extractDurationConfig(field reflect.StructField, value time.Duration) any {
+	if value == 0 {
+		if defaultValue := field.Tag.Get("default"); defaultValue != "" {
+			return defaultValue
+		}
+	}
+	return value.String()
+}
+
+func parseDefaultValue(defaultValue string, t reflect.Type) any {
+	switch t.Kind() {
+	case reflect.String:
+		return defaultValue
+	case reflect.Bool:
+		return defaultValue == "true"
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		if v, err := strconv.ParseInt(defaultValue, 10, 64); err == nil {
+			return v
+		}
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		if v, err := strconv.ParseUint(defaultValue, 10, 64); err == nil {
+			return v
+		}
+	case reflect.Float32, reflect.Float64:
+		if v, err := strconv.ParseFloat(defaultValue, 64); err == nil {
+			return v
+		}
+	}
+	return defaultValue
+}

doc/arch/auth.md

@@ -0,0 +1,279 @@
+# Stream Authentication Mechanism
+
+Monibuca V5 provides a comprehensive stream authentication mechanism to control access permissions for publishing and subscribing to streams. The authentication mechanism supports multiple methods, including key-based signature authentication and custom authentication handlers.
+
+## Authentication Principles
+
+### 1. Authentication Flow Sequence Diagrams
+
+#### Publishing Authentication Sequence Diagram
+
+```mermaid
+sequenceDiagram
+    participant Client as Publishing Client
+    participant Plugin as Plugin
+    participant AuthHandler as Auth Handler
+    participant Server as Server
+    
+    Client->>Plugin: Publishing Request (streamPath, args)
+    Plugin->>Plugin: Check EnableAuth && Type == PublishTypeServer
+    
+    alt Authentication Enabled
+        Plugin->>Plugin: Look for custom auth handler
+        
+        alt Custom Handler Exists
+            Plugin->>AuthHandler: onAuthPub(publisher)
+            AuthHandler->>AuthHandler: Execute custom auth logic
+            AuthHandler-->>Plugin: Auth result
+        else Use Key-based Auth
+            Plugin->>Plugin: Check if conf.Key exists
+            alt Key Configured
+                Plugin->>Plugin: auth(streamPath, key, secret, expire)
+                Plugin->>Plugin: Validate timestamp
+                Plugin->>Plugin: Validate secret length
+                Plugin->>Plugin: Calculate MD5 signature
+                Plugin->>Plugin: Compare signatures
+                Plugin-->>Plugin: Auth result
+            end
+        end
+        
+        alt Auth Failed
+            Plugin-->>Client: Auth failed, reject publishing
+        else Auth Success
+            Plugin->>Server: Create Publisher and add to stream management
+            Server-->>Plugin: Publishing successful
+            Plugin-->>Client: Publishing established successfully
+        end
+    else Auth Disabled
+        Plugin->>Server: Create Publisher directly
+        Server-->>Plugin: Publishing successful
+        Plugin-->>Client: Publishing established successfully
+    end
+```
+
+#### Subscribing Authentication Sequence Diagram
+
+```mermaid
+sequenceDiagram
+    participant Client as Subscribing Client
+    participant Plugin as Plugin
+    participant AuthHandler as Auth Handler
+    participant Server as Server
+    
+    Client->>Plugin: Subscribing Request (streamPath, args)
+    Plugin->>Plugin: Check EnableAuth && Type == SubscribeTypeServer
+    
+    alt Authentication Enabled
+        Plugin->>Plugin: Look for custom auth handler
+        
+        alt Custom Handler Exists
+            Plugin->>AuthHandler: onAuthSub(subscriber)
+            AuthHandler->>AuthHandler: Execute custom auth logic
+            AuthHandler-->>Plugin: Auth result
+        else Use Key-based Auth
+            Plugin->>Plugin: Check if conf.Key exists
+            alt Key Configured
+                Plugin->>Plugin: auth(streamPath, key, secret, expire)
+                Plugin->>Plugin: Validate timestamp
+                Plugin->>Plugin: Validate secret length
+                Plugin->>Plugin: Calculate MD5 signature
+                Plugin->>Plugin: Compare signatures
+                Plugin-->>Plugin: Auth result
+            end
+        end
+        
+        alt Auth Failed
+            Plugin-->>Client: Auth failed, reject subscribing
+        else Auth Success
+            Plugin->>Server: Create Subscriber and wait for Publisher
+            Server->>Server: Wait for stream publishing and track ready
+            Server-->>Plugin: Subscribing ready
+            Plugin-->>Client: Start streaming data transmission
+        end
+    else Auth Disabled
+        Plugin->>Server: Create Subscriber directly
+        Server-->>Plugin: Subscribing successful
+        Plugin-->>Client: Start streaming data transmission
+    end
+```
+
+### 2. Authentication Trigger Points
+
+Authentication is triggered in the following two scenarios:
+
+- **Publishing Authentication**: Triggered when there's a publishing request in the `PublishWithConfig` method
+- **Subscribing Authentication**: Triggered when there's a subscribing request in the `SubscribeWithConfig` method
+
+### 3. Authentication Condition Checks
+
+Authentication is only executed when the following conditions are met simultaneously:
+
+```go
+if p.config.EnableAuth && publisher.Type == PublishTypeServer
+```
+
+- `EnableAuth`: Authentication is enabled in the plugin configuration
+- `Type == PublishTypeServer/SubscribeTypeServer`: Only authenticate server-type publishing/subscribing
+
+### 4. Authentication Method Priority
+
+The system executes authentication in the following priority order:
+
+1. **Custom Authentication Handler** (Highest priority)
+2. **Key-based Signature Authentication**
+3. **No Authentication** (Default pass)
+
+## Custom Authentication Handlers
+
+### Publishing Authentication Handler
+
+```go
+onAuthPub := p.Meta.OnAuthPub
+if onAuthPub == nil {
+    onAuthPub = p.Server.Meta.OnAuthPub
+}
+if onAuthPub != nil {
+    if err = onAuthPub(publisher).Await(); err != nil {
+        p.Warn("auth failed", "error", err)
+        return
+    }
+}
+```
+
+Authentication handler lookup order:
+1. Plugin-level authentication handler `p.Meta.OnAuthPub`
+2. Server-level authentication handler `p.Server.Meta.OnAuthPub`
+
+### Subscribing Authentication Handler
+
+```go
+onAuthSub := p.Meta.OnAuthSub
+if onAuthSub == nil {
+    onAuthSub = p.Server.Meta.OnAuthSub
+}
+if onAuthSub != nil {
+    if err = onAuthSub(subscriber).Await(); err != nil {
+        p.Warn("auth failed", "error", err)
+        return
+    }
+}
+```
+
+## Key-based Signature Authentication
+
+When there's no custom authentication handler, if a Key is configured, the system will use MD5-based signature authentication mechanism.
+
+### Authentication Algorithm
+
+```go
+func (p *Plugin) auth(streamPath string, key string, secret string, expire string) (err error) {
+    // 1. Validate expiration time
+    if unixTime, err := strconv.ParseInt(expire, 16, 64); err != nil || time.Now().Unix() > unixTime {
+        return fmt.Errorf("auth failed expired")
+    }
+    
+    // 2. Validate secret length
+    if len(secret) != 32 {
+        return fmt.Errorf("auth failed secret length must be 32")
+    }
+    
+    // 3. Calculate the true secret
+    trueSecret := md5.Sum([]byte(key + streamPath + expire))
+    
+    // 4. Compare secrets
+    if secret == hex.EncodeToString(trueSecret[:]) {
+        return nil
+    }
+    return fmt.Errorf("auth failed invalid secret")
+}
+```
+
+### Signature Calculation Steps
+
+1. **Construct signature string**: `key + streamPath + expire`
+2. **MD5 encryption**: Perform MD5 hash on the signature string
+3. **Hexadecimal encoding**: Convert MD5 result to 32-character hexadecimal string
+4. **Verify signature**: Compare calculation result with client-provided secret
+
+### Parameter Description
+
+| Parameter | Type | Description | Example |
+|-----------|------|-------------|---------|
+| key | string | Secret key set in configuration file | "mySecretKey" |
+| streamPath | string | Stream path | "live/test" |
+| expire | string | Expiration timestamp (hexadecimal) | "64a1b2c3" |
+| secret | string | Client-calculated signature (32-char hex) | "5d41402abc4b2a76b9719d911017c592" |
+
+### Timestamp Handling
+
+- Expiration time uses hexadecimal Unix timestamp
+- System validates if current time exceeds expiration time
+- Timestamp parsing failure or expiration will cause authentication failure
+
+## API Key Generation
+
+The system also provides API interfaces for key generation, supporting authentication needs for admin dashboard:
+
+```go
+p.handle("/api/secret/{type}/{streamPath...}", http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
+    // JWT Token validation
+    authHeader := r.Header.Get("Authorization")
+    tokenString := strings.TrimPrefix(authHeader, "Bearer ")
+    _, err := p.Server.ValidateToken(tokenString)
+    
+    // Generate publishing or subscribing key
+    streamPath := r.PathValue("streamPath")
+    t := r.PathValue("type")
+    expire := r.URL.Query().Get("expire")
+    
+    if t == "publish" {
+        secret := md5.Sum([]byte(p.config.Publish.Key + streamPath + expire))
+        rw.Write([]byte(hex.EncodeToString(secret[:])))
+    } else if t == "subscribe" {
+        secret := md5.Sum([]byte(p.config.Subscribe.Key + streamPath + expire))
+        rw.Write([]byte(hex.EncodeToString(secret[:])))
+    }
+}))
+```
+
+## Configuration Examples
+
+### Enable Authentication
+
+```yaml
+# Plugin configuration
+rtmp:
+  enableAuth: true
+  publish:
+    key: "your-publish-key"
+  subscribe:
+    key: "your-subscribe-key"
+```
+
+### Publishing URL Example
+
+```
+rtmp://localhost/live/test?secret=5d41402abc4b2a76b9719d911017c592&expire=64a1b2c3
+```
+
+### Subscribing URL Example
+
+```
+http://localhost:8080/flv/live/test.flv?secret=a1b2c3d4e5f6789012345678901234ab&expire=64a1b2c3
+```
+
+## Security Considerations
+
+1. **Key Protection**: Keys in configuration files should be properly secured to prevent leakage
+2. **Time Window**: Set reasonable expiration times to balance security and usability
+3. **HTTPS Transport**: Use HTTPS for transmitting authentication parameters in production
+4. **Logging**: Authentication failures are logged as warnings for security auditing
+
+## Error Handling
+
+Common causes of authentication failure:
+
+- `auth failed expired`: Timestamp expired or format error
+- `auth failed secret length must be 32`: Incorrect secret length
+- `auth failed invalid secret`: Signature verification failed
+- `invalid token`: JWT verification failed during API key generation

doc/arch/index.md

@@ -26,7 +26,7 @@
 
 ### Plugin Development
 
-[plugin/README.md](../plugin/README.md)
+[plugin/README.md](../../plugin/README.md)
 
 ## Task System
 

doc_CN/arch/auth.md

@@ -0,0 +1,279 @@
+# 流鉴权机制
+
+Monibuca V5 提供了完善的流鉴权机制，用于控制推流和拉流的访问权限。鉴权机制支持多种方式，包括基于密钥的签名鉴权和自定义鉴权处理器。
+
+## 鉴权原理
+
+### 1. 鉴权流程时序图
+
+#### 推流鉴权时序图
+
+```mermaid
+sequenceDiagram
+    participant Client as 推流客户端
+    participant Plugin as 插件
+    participant AuthHandler as 鉴权处理器
+    participant Server as 服务器
+    
+    Client->>Plugin: 推流请求 (streamPath, args)
+    Plugin->>Plugin: 检查 EnableAuth && Type == PublishTypeServer
+    
+    alt 启用鉴权
+        Plugin->>Plugin: 查找自定义鉴权处理器
+        
+        alt 存在自定义处理器
+            Plugin->>AuthHandler: onAuthPub(publisher)
+            AuthHandler->>AuthHandler: 执行自定义鉴权逻辑
+            AuthHandler-->>Plugin: 鉴权结果
+        else 使用密钥鉴权
+            Plugin->>Plugin: 检查 conf.Key 是否存在
+            alt 配置了Key
+                Plugin->>Plugin: auth(streamPath, key, secret, expire)
+                Plugin->>Plugin: 验证时间戳
+                Plugin->>Plugin: 验证secret长度
+                Plugin->>Plugin: 计算MD5签名
+                Plugin->>Plugin: 比较签名
+                Plugin-->>Plugin: 鉴权结果
+            end
+        end
+        
+        alt 鉴权失败
+            Plugin-->>Client: 鉴权失败，拒绝推流
+        else 鉴权成功
+            Plugin->>Server: 创建Publisher并添加到流管理
+            Server-->>Plugin: 推流成功
+            Plugin-->>Client: 推流建立成功
+        end
+    else 未启用鉴权
+        Plugin->>Server: 直接创建Publisher
+        Server-->>Plugin: 推流成功
+        Plugin-->>Client: 推流建立成功
+    end
+```
+
+#### 拉流鉴权时序图
+
+```mermaid
+sequenceDiagram
+    participant Client as 拉流客户端
+    participant Plugin as 插件
+    participant AuthHandler as 鉴权处理器
+    participant Server as 服务器
+    
+    Client->>Plugin: 拉流请求 (streamPath, args)
+    Plugin->>Plugin: 检查 EnableAuth && Type == SubscribeTypeServer
+    
+    alt 启用鉴权
+        Plugin->>Plugin: 查找自定义鉴权处理器
+        
+        alt 存在自定义处理器
+            Plugin->>AuthHandler: onAuthSub(subscriber)
+            AuthHandler->>AuthHandler: 执行自定义鉴权逻辑
+            AuthHandler-->>Plugin: 鉴权结果
+        else 使用密钥鉴权
+            Plugin->>Plugin: 检查 conf.Key 是否存在
+            alt 配置了Key
+                Plugin->>Plugin: auth(streamPath, key, secret, expire)
+                Plugin->>Plugin: 验证时间戳
+                Plugin->>Plugin: 验证secret长度
+                Plugin->>Plugin: 计算MD5签名
+                Plugin->>Plugin: 比较签名
+                Plugin-->>Plugin: 鉴权结果
+            end
+        end
+        
+        alt 鉴权失败
+            Plugin-->>Client: 鉴权失败，拒绝拉流
+        else 鉴权成功
+            Plugin->>Server: 创建Subscriber并等待Publisher
+            Server->>Server: 等待流发布和轨道就绪
+            Server-->>Plugin: 拉流准备就绪
+            Plugin-->>Client: 开始传输流数据
+        end
+    else 未启用鉴权
+        Plugin->>Server: 直接创建Subscriber
+        Server-->>Plugin: 拉流成功
+        Plugin-->>Client: 开始传输流数据
+    end
+```
+
+### 2. 鉴权触发时机
+
+鉴权在以下两种情况下触发：
+
+- **推流鉴权**：当有推流请求时，在`PublishWithConfig`方法中触发
+- **拉流鉴权**：当有拉流请求时，在`SubscribeWithConfig`方法中触发
+
+### 3. 鉴权条件判断
+
+鉴权只在以下条件同时满足时才会执行：
+
+```go
+if p.config.EnableAuth && publisher.Type == PublishTypeServer
+```
+
+- `EnableAuth`：插件配置中启用了鉴权
+- `Type == PublishTypeServer/SubscribeTypeServer`：只对服务端类型的推流/拉流进行鉴权
+
+### 4. 鉴权方式优先级
+
+系统按以下优先级执行鉴权：
+
+1. **自定义鉴权处理器**（最高优先级）
+2. **基于密钥的签名鉴权**
+3. **无鉴权**（默认通过）
+
+## 自定义鉴权处理器
+
+### 推流鉴权处理器
+
+```go
+onAuthPub := p.Meta.OnAuthPub
+if onAuthPub == nil {
+    onAuthPub = p.Server.Meta.OnAuthPub
+}
+if onAuthPub != nil {
+    if err = onAuthPub(publisher).Await(); err != nil {
+        p.Warn("auth failed", "error", err)
+        return
+    }
+}
+```
+
+鉴权处理器查找顺序：
+1. 插件级别的鉴权处理器 `p.Meta.OnAuthPub`
+2. 服务器级别的鉴权处理器 `p.Server.Meta.OnAuthPub`
+
+### 拉流鉴权处理器
+
+```go
+onAuthSub := p.Meta.OnAuthSub
+if onAuthSub == nil {
+    onAuthSub = p.Server.Meta.OnAuthSub
+}
+if onAuthSub != nil {
+    if err = onAuthSub(subscriber).Await(); err != nil {
+        p.Warn("auth failed", "error", err)
+        return
+    }
+}
+```
+
+## 基于密钥的签名鉴权
+
+当没有自定义鉴权处理器时，如果配置了Key，系统将使用基于MD5的签名鉴权机制。
+
+### 鉴权算法
+
+```go
+func (p *Plugin) auth(streamPath string, key string, secret string, expire string) (err error) {
+    // 1. 验证过期时间
+    if unixTime, err := strconv.ParseInt(expire, 16, 64); err != nil || time.Now().Unix() > unixTime {
+        return fmt.Errorf("auth failed expired")
+    }
+    
+    // 2. 验证secret长度
+    if len(secret) != 32 {
+        return fmt.Errorf("auth failed secret length must be 32")
+    }
+    
+    // 3. 计算真实的secret
+    trueSecret := md5.Sum([]byte(key + streamPath + expire))
+    
+    // 4. 比较secret
+    if secret == hex.EncodeToString(trueSecret[:]) {
+        return nil
+    }
+    return fmt.Errorf("auth failed invalid secret")
+}
+```
+
+### 签名计算步骤
+
+1. **构造签名字符串**：`key + streamPath + expire`
+2. **MD5加密**：对签名字符串进行MD5哈希
+3. **十六进制编码**：将MD5结果转换为32位十六进制字符串
+4. **验证签名**：比较计算结果与客户端提供的secret
+
+### 参数说明
+
+| 参数 | 类型 | 说明 | 示例 |
+|------|------|------|------|
+| key | string | 密钥，在配置文件中设置 | "mySecretKey" |
+| streamPath | string | 流路径 | "live/test" |
+| expire | string | 过期时间戳（16进制） | "64a1b2c3" |
+| secret | string | 客户端计算的签名（32位十六进制） | "5d41402abc4b2a76b9719d911017c592" |
+
+### 时间戳处理
+
+- 过期时间使用16进制Unix时间戳
+- 系统会验证当前时间是否超过过期时间
+- 时间戳解析失败或已过期都会导致鉴权失败
+
+## API密钥生成
+
+系统还提供了API接口用于生成密钥，支持管理后台的鉴权需求：
+
+```go
+p.handle("/api/secret/{type}/{streamPath...}", http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
+    // JWT Token验证
+    authHeader := r.Header.Get("Authorization")
+    tokenString := strings.TrimPrefix(authHeader, "Bearer ")
+    _, err := p.Server.ValidateToken(tokenString)
+    
+    // 生成推流或拉流密钥
+    streamPath := r.PathValue("streamPath")
+    t := r.PathValue("type")
+    expire := r.URL.Query().Get("expire")
+    
+    if t == "publish" {
+        secret := md5.Sum([]byte(p.config.Publish.Key + streamPath + expire))
+        rw.Write([]byte(hex.EncodeToString(secret[:])))
+    } else if t == "subscribe" {
+        secret := md5.Sum([]byte(p.config.Subscribe.Key + streamPath + expire))
+        rw.Write([]byte(hex.EncodeToString(secret[:])))
+    }
+}))
+```
+
+## 配置示例
+
+### 启用鉴权
+
+```yaml
+# 插件配置
+rtmp:
+  enableAuth: true
+  publish:
+    key: "your-publish-key"
+  subscribe:
+    key: "your-subscribe-key"
+```
+
+### 推流URL示例
+
+```
+rtmp://localhost/live/test?secret=5d41402abc4b2a76b9719d911017c592&expire=64a1b2c3
+```
+
+### 拉流URL示例
+
+```
+http://localhost:8080/flv/live/test.flv?secret=a1b2c3d4e5f6789012345678901234ab&expire=64a1b2c3
+```
+
+## 安全考虑
+
+1. **密钥保护**：配置文件中的key应当妥善保管，避免泄露
+2. **时间窗口**：合理设置过期时间，平衡安全性和可用性
+3. **HTTPS传输**：生产环境建议使用HTTPS传输鉴权参数
+4. **日志记录**：鉴权失败会记录警告日志，便于安全审计
+
+## 错误处理
+
+鉴权失败的常见原因：
+
+- `auth failed expired`：时间戳已过期或格式错误
+- `auth failed secret length must be 32`：secret长度不正确
+- `auth failed invalid secret`：签名验证失败
+- `invalid token`：API密钥生成时JWT验证失败

example/default/config.yaml

@@ -15,13 +15,33 @@ gb28181:
   sip:
     listenaddr:
           - udp::5060
-  # pull:
-  #   live/test: dump/34020000001320000001
   onsub:
     pull:
       ^\d{20}/\d{20}$: $0
       ^gb_\d+/(.+)$: $1
 #      .* : $0
+  platforms:
+    - enable: false  #是否启用平台
+      name: "测试平台" #平台名称
+      servergbid: "34020000002000000002" #上级平台GBID
+      servergbdomain: "3402000000" #上级平台GB域
+      serverip: 192.168.1.106 #上级平台IP
+      serverport: 5061 #上级平台端口
+      devicegbid: "34020000002000000001" #本平台设备GBID
+      deviceip: 192.168.1.106 #本平台设备IP
+      deviceport: 5060 #本平台设备端口
+      username: "34020000002000000001" #SIP账号
+      password: "123456" #SIP密码
+      expires: 3600 #注册有效期，单位秒
+      keeptimeout: 60 #注册保持超时时间，单位秒
+      civilCode: "340200" #行政区划代码
+      manufacturer: "Monibuca" #设备制造商
+      model: "GB28181" #设备型号
+      address: "江苏南京" #设备地址
+      register_way: 1
+      platformchannels:
+        - platformservergbid: "34020000002000000002" #上级平台GBID
+          channeldbid: "34020000001110000003_34020000001320000005" #通道DBID,格式为设备ID_通道ID
 mp4:
   # enable: false
   # publish:

go.mod

@@ -53,7 +53,7 @@ require (
 	google.golang.org/protobuf v1.34.2
 	gorm.io/driver/mysql v1.5.7
 	gorm.io/driver/postgres v1.5.9
-	gorm.io/gorm v1.25.11
+	gorm.io/gorm v1.30.0
 )
 
 require (

go.sum

@@ -423,8 +423,8 @@ gorm.io/driver/mysql v1.5.7/go.mod h1:sEtPWMiqiN1N1cMXoXmBbd8C6/l+TESwriotuRRpkD
 gorm.io/driver/postgres v1.5.9 h1:DkegyItji119OlcaLjqN11kHoUgZ/j13E0jkJZgD6A8=
 gorm.io/driver/postgres v1.5.9/go.mod h1:DX3GReXH+3FPWGrrgffdvCk3DQ1dwDPdmbenSkweRGI=
 gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
-gorm.io/gorm v1.25.11 h1:/Wfyg1B/je1hnDx3sMkX+gAlxrlZpn6X0BXRlwXlvHg=
-gorm.io/gorm v1.25.11/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ=
+gorm.io/gorm v1.30.0 h1:qbT5aPv1UH8gI99OsRlvDToLxW5zR7FzS9acZDOZcgs=
+gorm.io/gorm v1.30.0/go.mod h1:8Z33v652h4//uMA76KjeDH8mJXPm1QNCYrMeatR0DOE=
 gotest.tools/v3 v3.0.2/go.mod h1:3SzNCllyD9/Y+b5r9JIKQ474KzkZyqLqEfYqMsX94Bk=
 gotest.tools/v3 v3.5.0 h1:Ljk6PdHdOhAb5aDMWXjDLMMhph+BpztA4v1QdqEW2eY=
 gotest.tools/v3 v3.5.0/go.mod h1:isy3WKz7GK6uNw/sbHzfKBLvlvXwUyV06n6brMxxopU=

pb/global.pb.go

@@ -4010,9 +4010,8 @@ type ReqRecordList struct {
 	End           string                 `protobuf:"bytes,4,opt,name=end,proto3" json:"end,omitempty"`
 	PageNum       uint32                 `protobuf:"varint,5,opt,name=pageNum,proto3" json:"pageNum,omitempty"`
 	PageSize      uint32                 `protobuf:"varint,6,opt,name=pageSize,proto3" json:"pageSize,omitempty"`
-	Mode          string                 `protobuf:"bytes,7,opt,name=mode,proto3" json:"mode,omitempty"`
-	Type          string                 `protobuf:"bytes,8,opt,name=type,proto3" json:"type,omitempty"`
-	EventLevel    string                 `protobuf:"bytes,9,opt,name=eventLevel,proto3" json:"eventLevel,omitempty"`
+	Type          string                 `protobuf:"bytes,7,opt,name=type,proto3" json:"type,omitempty"`
+	EventLevel    string                 `protobuf:"bytes,8,opt,name=eventLevel,proto3" json:"eventLevel,omitempty"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }
@@ -4089,13 +4088,6 @@ func (x *ReqRecordList) GetPageSize() uint32 {
 	return 0
 }
 
-func (x *ReqRecordList) GetMode() string {
-	if x != nil {
-		return x.Mode
-	}
-	return ""
-}
-
 func (x *ReqRecordList) GetType() string {
 	if x != nil {
 		return x.Type
@@ -4117,9 +4109,6 @@ type RecordFile struct {
 	StreamPath    string                 `protobuf:"bytes,3,opt,name=streamPath,proto3" json:"streamPath,omitempty"`
 	StartTime     *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=startTime,proto3" json:"startTime,omitempty"`
 	EndTime       *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=endTime,proto3" json:"endTime,omitempty"`
-	EventLevel    string                 `protobuf:"bytes,6,opt,name=eventLevel,proto3" json:"eventLevel,omitempty"`
-	EventName     string                 `protobuf:"bytes,7,opt,name=eventName,proto3" json:"eventName,omitempty"`
-	EventDesc     string                 `protobuf:"bytes,8,opt,name=eventDesc,proto3" json:"eventDesc,omitempty"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }
@@ -4189,53 +4178,35 @@ func (x *RecordFile) GetEndTime() *timestamppb.Timestamp {
 	return nil
 }
 
-func (x *RecordFile) GetEventLevel() string {
-	if x != nil {
-		return x.EventLevel
-	}
-	return ""
-}
-
-func (x *RecordFile) GetEventName() string {
-	if x != nil {
-		return x.EventName
-	}
-	return ""
-}
-
-func (x *RecordFile) GetEventDesc() string {
-	if x != nil {
-		return x.EventDesc
-	}
-	return ""
-}
-
-type ResponseList struct {
+type EventRecordFile struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
-	Code          int32                  `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
-	Message       string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
-	Total         uint32                 `protobuf:"varint,3,opt,name=total,proto3" json:"total,omitempty"`
-	PageNum       uint32                 `protobuf:"varint,4,opt,name=pageNum,proto3" json:"pageNum,omitempty"`
-	PageSize      uint32                 `protobuf:"varint,5,opt,name=pageSize,proto3" json:"pageSize,omitempty"`
-	Data          []*RecordFile          `protobuf:"bytes,6,rep,name=data,proto3" json:"data,omitempty"`
+	Id            uint32                 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
+	FilePath      string                 `protobuf:"bytes,2,opt,name=filePath,proto3" json:"filePath,omitempty"`
+	StreamPath    string                 `protobuf:"bytes,3,opt,name=streamPath,proto3" json:"streamPath,omitempty"`
+	StartTime     *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=startTime,proto3" json:"startTime,omitempty"`
+	EndTime       *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=endTime,proto3" json:"endTime,omitempty"`
+	EventId       string                 `protobuf:"bytes,6,opt,name=eventId,proto3" json:"eventId,omitempty"`
+	EventLevel    string                 `protobuf:"bytes,7,opt,name=eventLevel,proto3" json:"eventLevel,omitempty"`
+	EventName     string                 `protobuf:"bytes,8,opt,name=eventName,proto3" json:"eventName,omitempty"`
+	EventDesc     string                 `protobuf:"bytes,9,opt,name=eventDesc,proto3" json:"eventDesc,omitempty"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }
 
-func (x *ResponseList) Reset() {
-	*x = ResponseList{}
+func (x *EventRecordFile) Reset() {
+	*x = EventRecordFile{}
 	mi := &file_global_proto_msgTypes[58]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *ResponseList) String() string {
+func (x *EventRecordFile) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*ResponseList) ProtoMessage() {}
+func (*EventRecordFile) ProtoMessage() {}
 
-func (x *ResponseList) ProtoReflect() protoreflect.Message {
+func (x *EventRecordFile) ProtoReflect() protoreflect.Message {
 	mi := &file_global_proto_msgTypes[58]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -4247,47 +4218,236 @@ func (x *ResponseList) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use ResponseList.ProtoReflect.Descriptor instead.
-func (*ResponseList) Descriptor() ([]byte, []int) {
+// Deprecated: Use EventRecordFile.ProtoReflect.Descriptor instead.
+func (*EventRecordFile) Descriptor() ([]byte, []int) {
 	return file_global_proto_rawDescGZIP(), []int{58}
 }
 
-func (x *ResponseList) GetCode() int32 {
+func (x *EventRecordFile) GetId() uint32 {
+	if x != nil {
+		return x.Id
+	}
+	return 0
+}
+
+func (x *EventRecordFile) GetFilePath() string {
+	if x != nil {
+		return x.FilePath
+	}
+	return ""
+}
+
+func (x *EventRecordFile) GetStreamPath() string {
+	if x != nil {
+		return x.StreamPath
+	}
+	return ""
+}
+
+func (x *EventRecordFile) GetStartTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.StartTime
+	}
+	return nil
+}
+
+func (x *EventRecordFile) GetEndTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.EndTime
+	}
+	return nil
+}
+
+func (x *EventRecordFile) GetEventId() string {
+	if x != nil {
+		return x.EventId
+	}
+	return ""
+}
+
+func (x *EventRecordFile) GetEventLevel() string {
+	if x != nil {
+		return x.EventLevel
+	}
+	return ""
+}
+
+func (x *EventRecordFile) GetEventName() string {
+	if x != nil {
+		return x.EventName
+	}
+	return ""
+}
+
+func (x *EventRecordFile) GetEventDesc() string {
+	if x != nil {
+		return x.EventDesc
+	}
+	return ""
+}
+
+type RecordResponseList struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Code          int32                  `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
+	Message       string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
+	Total         uint32                 `protobuf:"varint,3,opt,name=total,proto3" json:"total,omitempty"`
+	PageNum       uint32                 `protobuf:"varint,4,opt,name=pageNum,proto3" json:"pageNum,omitempty"`
+	PageSize      uint32                 `protobuf:"varint,5,opt,name=pageSize,proto3" json:"pageSize,omitempty"`
+	Data          []*RecordFile          `protobuf:"bytes,6,rep,name=data,proto3" json:"data,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *RecordResponseList) Reset() {
+	*x = RecordResponseList{}
+	mi := &file_global_proto_msgTypes[59]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *RecordResponseList) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RecordResponseList) ProtoMessage() {}
+
+func (x *RecordResponseList) ProtoReflect() protoreflect.Message {
+	mi := &file_global_proto_msgTypes[59]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RecordResponseList.ProtoReflect.Descriptor instead.
+func (*RecordResponseList) Descriptor() ([]byte, []int) {
+	return file_global_proto_rawDescGZIP(), []int{59}
+}
+
+func (x *RecordResponseList) GetCode() int32 {
 	if x != nil {
 		return x.Code
 	}
 	return 0
 }
 
-func (x *ResponseList) GetMessage() string {
+func (x *RecordResponseList) GetMessage() string {
 	if x != nil {
 		return x.Message
 	}
 	return ""
 }
 
-func (x *ResponseList) GetTotal() uint32 {
+func (x *RecordResponseList) GetTotal() uint32 {
 	if x != nil {
 		return x.Total
 	}
 	return 0
 }
 
-func (x *ResponseList) GetPageNum() uint32 {
+func (x *RecordResponseList) GetPageNum() uint32 {
 	if x != nil {
 		return x.PageNum
 	}
 	return 0
 }
 
-func (x *ResponseList) GetPageSize() uint32 {
+func (x *RecordResponseList) GetPageSize() uint32 {
 	if x != nil {
 		return x.PageSize
 	}
 	return 0
 }
 
-func (x *ResponseList) GetData() []*RecordFile {
+func (x *RecordResponseList) GetData() []*RecordFile {
+	if x != nil {
+		return x.Data
+	}
+	return nil
+}
+
+type EventRecordResponseList struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Code          int32                  `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
+	Message       string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
+	Total         uint32                 `protobuf:"varint,3,opt,name=total,proto3" json:"total,omitempty"`
+	PageNum       uint32                 `protobuf:"varint,4,opt,name=pageNum,proto3" json:"pageNum,omitempty"`
+	PageSize      uint32                 `protobuf:"varint,5,opt,name=pageSize,proto3" json:"pageSize,omitempty"`
+	Data          []*EventRecordFile     `protobuf:"bytes,6,rep,name=data,proto3" json:"data,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *EventRecordResponseList) Reset() {
+	*x = EventRecordResponseList{}
+	mi := &file_global_proto_msgTypes[60]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *EventRecordResponseList) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EventRecordResponseList) ProtoMessage() {}
+
+func (x *EventRecordResponseList) ProtoReflect() protoreflect.Message {
+	mi := &file_global_proto_msgTypes[60]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use EventRecordResponseList.ProtoReflect.Descriptor instead.
+func (*EventRecordResponseList) Descriptor() ([]byte, []int) {
+	return file_global_proto_rawDescGZIP(), []int{60}
+}
+
+func (x *EventRecordResponseList) GetCode() int32 {
+	if x != nil {
+		return x.Code
+	}
+	return 0
+}
+
+func (x *EventRecordResponseList) GetMessage() string {
+	if x != nil {
+		return x.Message
+	}
+	return ""
+}
+
+func (x *EventRecordResponseList) GetTotal() uint32 {
+	if x != nil {
+		return x.Total
+	}
+	return 0
+}
+
+func (x *EventRecordResponseList) GetPageNum() uint32 {
+	if x != nil {
+		return x.PageNum
+	}
+	return 0
+}
+
+func (x *EventRecordResponseList) GetPageSize() uint32 {
+	if x != nil {
+		return x.PageSize
+	}
+	return 0
+}
+
+func (x *EventRecordResponseList) GetData() []*EventRecordFile {
 	if x != nil {
 		return x.Data
 	}
@@ -4306,7 +4466,7 @@ type Catalog struct {
 
 func (x *Catalog) Reset() {
 	*x = Catalog{}
-	mi := &file_global_proto_msgTypes[59]
+	mi := &file_global_proto_msgTypes[61]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -4318,7 +4478,7 @@ func (x *Catalog) String() string {
 func (*Catalog) ProtoMessage() {}
 
 func (x *Catalog) ProtoReflect() protoreflect.Message {
-	mi := &file_global_proto_msgTypes[59]
+	mi := &file_global_proto_msgTypes[61]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -4331,7 +4491,7 @@ func (x *Catalog) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Catalog.ProtoReflect.Descriptor instead.
 func (*Catalog) Descriptor() ([]byte, []int) {
-	return file_global_proto_rawDescGZIP(), []int{59}
+	return file_global_proto_rawDescGZIP(), []int{61}
 }
 
 func (x *Catalog) GetStreamPath() string {
@@ -4373,7 +4533,7 @@ type ResponseCatalog struct {
 
 func (x *ResponseCatalog) Reset() {
 	*x = ResponseCatalog{}
-	mi := &file_global_proto_msgTypes[60]
+	mi := &file_global_proto_msgTypes[62]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -4385,7 +4545,7 @@ func (x *ResponseCatalog) String() string {
 func (*ResponseCatalog) ProtoMessage() {}
 
 func (x *ResponseCatalog) ProtoReflect() protoreflect.Message {
-	mi := &file_global_proto_msgTypes[60]
+	mi := &file_global_proto_msgTypes[62]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -4398,7 +4558,7 @@ func (x *ResponseCatalog) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ResponseCatalog.ProtoReflect.Descriptor instead.
 func (*ResponseCatalog) Descriptor() ([]byte, []int) {
-	return file_global_proto_rawDescGZIP(), []int{60}
+	return file_global_proto_rawDescGZIP(), []int{62}
 }
 
 func (x *ResponseCatalog) GetCode() int32 {
@@ -4436,7 +4596,7 @@ type ReqRecordDelete struct {
 
 func (x *ReqRecordDelete) Reset() {
 	*x = ReqRecordDelete{}
-	mi := &file_global_proto_msgTypes[61]
+	mi := &file_global_proto_msgTypes[63]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -4448,7 +4608,7 @@ func (x *ReqRecordDelete) String() string {
 func (*ReqRecordDelete) ProtoMessage() {}
 
 func (x *ReqRecordDelete) ProtoReflect() protoreflect.Message {
-	mi := &file_global_proto_msgTypes[61]
+	mi := &file_global_proto_msgTypes[63]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -4461,7 +4621,7 @@ func (x *ReqRecordDelete) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ReqRecordDelete.ProtoReflect.Descriptor instead.
 func (*ReqRecordDelete) Descriptor() ([]byte, []int) {
-	return file_global_proto_rawDescGZIP(), []int{61}
+	return file_global_proto_rawDescGZIP(), []int{63}
 }
 
 func (x *ReqRecordDelete) GetStreamPath() string {
@@ -4517,7 +4677,7 @@ type ResponseDelete struct {
 
 func (x *ResponseDelete) Reset() {
 	*x = ResponseDelete{}
-	mi := &file_global_proto_msgTypes[62]
+	mi := &file_global_proto_msgTypes[64]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -4529,7 +4689,7 @@ func (x *ResponseDelete) String() string {
 func (*ResponseDelete) ProtoMessage() {}
 
 func (x *ResponseDelete) ProtoReflect() protoreflect.Message {
-	mi := &file_global_proto_msgTypes[62]
+	mi := &file_global_proto_msgTypes[64]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -4542,7 +4702,7 @@ func (x *ResponseDelete) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ResponseDelete.ProtoReflect.Descriptor instead.
 func (*ResponseDelete) Descriptor() ([]byte, []int) {
-	return file_global_proto_rawDescGZIP(), []int{62}
+	return file_global_proto_rawDescGZIP(), []int{64}
 }
 
 func (x *ResponseDelete) GetCode() int32 {
@@ -4575,7 +4735,7 @@ type ReqRecordCatalog struct {
 
 func (x *ReqRecordCatalog) Reset() {
 	*x = ReqRecordCatalog{}
-	mi := &file_global_proto_msgTypes[63]
+	mi := &file_global_proto_msgTypes[65]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -4587,7 +4747,7 @@ func (x *ReqRecordCatalog) String() string {
 func (*ReqRecordCatalog) ProtoMessage() {}
 
 func (x *ReqRecordCatalog) ProtoReflect() protoreflect.Message {
-	mi := &file_global_proto_msgTypes[63]
+	mi := &file_global_proto_msgTypes[65]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -4600,7 +4760,7 @@ func (x *ReqRecordCatalog) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ReqRecordCatalog.ProtoReflect.Descriptor instead.
 func (*ReqRecordCatalog) Descriptor() ([]byte, []int) {
-	return file_global_proto_rawDescGZIP(), []int{63}
+	return file_global_proto_rawDescGZIP(), []int{65}
 }
 
 func (x *ReqRecordCatalog) GetType() string {
@@ -5015,7 +5175,7 @@ const file_global_proto_rawDesc = "" +
 	"\x15TransformListResponse\x12\x12\n" +
 	"\x04code\x18\x01 \x01(\x05R\x04code\x12\x18\n" +
 	"\amessage\x18\x02 \x01(\tR\amessage\x12%\n" +
-	"\x04data\x18\x03 \x03(\v2\x11.global.TransformR\x04data\"\xeb\x01\n" +
+	"\x04data\x18\x03 \x03(\v2\x11.global.TransformR\x04data\"\xd7\x01\n" +
 	"\rReqRecordList\x12\x1e\n" +
 	"\n" +
 	"streamPath\x18\x01 \x01(\tR\n" +
@@ -5025,11 +5185,10 @@ const file_global_proto_rawDesc = "" +
 	"\x03end\x18\x04 \x01(\tR\x03end\x12\x18\n" +
 	"\apageNum\x18\x05 \x01(\rR\apageNum\x12\x1a\n" +
 	"\bpageSize\x18\x06 \x01(\rR\bpageSize\x12\x12\n" +
-	"\x04mode\x18\a \x01(\tR\x04mode\x12\x12\n" +
-	"\x04type\x18\b \x01(\tR\x04type\x12\x1e\n" +
+	"\x04type\x18\a \x01(\tR\x04type\x12\x1e\n" +
 	"\n" +
-	"eventLevel\x18\t \x01(\tR\n" +
-	"eventLevel\"\xa4\x02\n" +
+	"eventLevel\x18\b \x01(\tR\n" +
+	"eventLevel\"\xc8\x01\n" +
 	"\n" +
 	"RecordFile\x12\x0e\n" +
 	"\x02id\x18\x01 \x01(\rR\x02id\x12\x1a\n" +
@@ -5038,19 +5197,35 @@ const file_global_proto_rawDesc = "" +
 	"streamPath\x18\x03 \x01(\tR\n" +
 	"streamPath\x128\n" +
 	"\tstartTime\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\tstartTime\x124\n" +
-	"\aendTime\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\aendTime\x12\x1e\n" +
+	"\aendTime\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\aendTime\"\xc3\x02\n" +
+	"\x0fEventRecordFile\x12\x0e\n" +
+	"\x02id\x18\x01 \x01(\rR\x02id\x12\x1a\n" +
+	"\bfilePath\x18\x02 \x01(\tR\bfilePath\x12\x1e\n" +
 	"\n" +
-	"eventLevel\x18\x06 \x01(\tR\n" +
+	"streamPath\x18\x03 \x01(\tR\n" +
+	"streamPath\x128\n" +
+	"\tstartTime\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\tstartTime\x124\n" +
+	"\aendTime\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\aendTime\x12\x18\n" +
+	"\aeventId\x18\x06 \x01(\tR\aeventId\x12\x1e\n" +
+	"\n" +
+	"eventLevel\x18\a \x01(\tR\n" +
 	"eventLevel\x12\x1c\n" +
-	"\teventName\x18\a \x01(\tR\teventName\x12\x1c\n" +
-	"\teventDesc\x18\b \x01(\tR\teventDesc\"\xb0\x01\n" +
-	"\fResponseList\x12\x12\n" +
+	"\teventName\x18\b \x01(\tR\teventName\x12\x1c\n" +
+	"\teventDesc\x18\t \x01(\tR\teventDesc\"\xb6\x01\n" +
+	"\x12RecordResponseList\x12\x12\n" +
 	"\x04code\x18\x01 \x01(\x05R\x04code\x12\x18\n" +
 	"\amessage\x18\x02 \x01(\tR\amessage\x12\x14\n" +
 	"\x05total\x18\x03 \x01(\rR\x05total\x12\x18\n" +
 	"\apageNum\x18\x04 \x01(\rR\apageNum\x12\x1a\n" +
 	"\bpageSize\x18\x05 \x01(\rR\bpageSize\x12&\n" +
-	"\x04data\x18\x06 \x03(\v2\x12.global.RecordFileR\x04data\"\xaf\x01\n" +
+	"\x04data\x18\x06 \x03(\v2\x12.global.RecordFileR\x04data\"\xc0\x01\n" +
+	"\x17EventRecordResponseList\x12\x12\n" +
+	"\x04code\x18\x01 \x01(\x05R\x04code\x12\x18\n" +
+	"\amessage\x18\x02 \x01(\tR\amessage\x12\x14\n" +
+	"\x05total\x18\x03 \x01(\rR\x05total\x12\x18\n" +
+	"\apageNum\x18\x04 \x01(\rR\apageNum\x12\x1a\n" +
+	"\bpageSize\x18\x05 \x01(\rR\bpageSize\x12+\n" +
+	"\x04data\x18\x06 \x03(\v2\x17.global.EventRecordFileR\x04data\"\xaf\x01\n" +
 	"\aCatalog\x12\x1e\n" +
 	"\n" +
 	"streamPath\x18\x01 \x01(\tR\n" +
@@ -5076,7 +5251,7 @@ const file_global_proto_rawDesc = "" +
 	"\amessage\x18\x02 \x01(\tR\amessage\x12&\n" +
 	"\x04data\x18\x03 \x03(\v2\x12.global.RecordFileR\x04data\"&\n" +
 	"\x10ReqRecordCatalog\x12\x12\n" +
-	"\x04type\x18\x01 \x01(\tR\x04type2\xae!\n" +
+	"\x04type\x18\x01 \x01(\tR\x04type2\xba\"\n" +
 	"\x03api\x12P\n" +
 	"\aSysInfo\x12\x16.google.protobuf.Empty\x1a\x17.global.SysInfoResponse\"\x14\x82\xd3\xe4\x93\x02\x0e\x12\f/api/sysinfo\x12i\n" +
 	"\x0fDisabledPlugins\x12\x16.google.protobuf.Empty\x1a\x1f.global.DisabledPluginsResponse\"\x1d\x82\xd3\xe4\x93\x02\x17\x12\x15/api/plugins/disabled\x12P\n" +
@@ -5118,8 +5293,9 @@ const file_global_proto_rawDesc = "" +
 	"\x0fRemovePushProxy\x12\x15.global.RequestWithId\x1a\x17.global.SuccessResponse\"&\x82\xd3\xe4\x93\x02 :\x01*\"\x1b/api/proxy/push/remove/{id}\x12d\n" +
 	"\x0fUpdatePushProxy\x12\x15.global.PushProxyInfo\x1a\x17.global.SuccessResponse\"!\x82\xd3\xe4\x93\x02\x1b:\x01*\"\x16/api/proxy/push/update\x12_\n" +
 	"\fGetRecording\x12\x16.google.protobuf.Empty\x1a\x1d.global.RecordingListResponse\"\x18\x82\xd3\xe4\x93\x02\x12\x12\x10/api/record/list\x12f\n" +
-	"\x10GetTransformList\x12\x16.google.protobuf.Empty\x1a\x1d.global.TransformListResponse\"\x1b\x82\xd3\xe4\x93\x02\x15\x12\x13/api/transform/list\x12m\n" +
-	"\rGetRecordList\x12\x15.global.ReqRecordList\x1a\x14.global.ResponseList\"/\x82\xd3\xe4\x93\x02)\x12'/api/record/{type}/list/{streamPath=**}\x12i\n" +
+	"\x10GetTransformList\x12\x16.google.protobuf.Empty\x1a\x1d.global.TransformListResponse\"\x1b\x82\xd3\xe4\x93\x02\x15\x12\x13/api/transform/list\x12s\n" +
+	"\rGetRecordList\x12\x15.global.ReqRecordList\x1a\x1a.global.RecordResponseList\"/\x82\xd3\xe4\x93\x02)\x12'/api/record/{type}/list/{streamPath=**}\x12\x83\x01\n" +
+	"\x12GetEventRecordList\x12\x15.global.ReqRecordList\x1a\x1f.global.EventRecordResponseList\"5\x82\xd3\xe4\x93\x02/\x12-/api/record/{type}/event/list/{streamPath=**}\x12i\n" +
 	"\x10GetRecordCatalog\x12\x18.global.ReqRecordCatalog\x1a\x17.global.ResponseCatalog\"\"\x82\xd3\xe4\x93\x02\x1c\x12\x1a/api/record/{type}/catalog\x12u\n" +
 	"\fDeleteRecord\x12\x17.global.ReqRecordDelete\x1a\x16.global.ResponseDelete\"4\x82\xd3\xe4\x93\x02.:\x01*\")/api/record/{type}/delete/{streamPath=**}B\x10Z\x0em7s.live/v5/pbb\x06proto3"
 
@@ -5135,7 +5311,7 @@ func file_global_proto_rawDescGZIP() []byte {
 	return file_global_proto_rawDescData
 }
 
-var file_global_proto_msgTypes = make([]protoimpl.MessageInfo, 71)
+var file_global_proto_msgTypes = make([]protoimpl.MessageInfo, 73)
 var file_global_proto_goTypes = []any{
 	(*DisabledPluginsResponse)(nil), // 0: global.DisabledPluginsResponse
 	(*GetConfigRequest)(nil),        // 1: global.GetConfigRequest
@@ -5195,171 +5371,178 @@ var file_global_proto_goTypes = []any{
 	(*TransformListResponse)(nil),   // 55: global.TransformListResponse
 	(*ReqRecordList)(nil),           // 56: global.ReqRecordList
 	(*RecordFile)(nil),              // 57: global.RecordFile
-	(*ResponseList)(nil),            // 58: global.ResponseList
-	(*Catalog)(nil),                 // 59: global.Catalog
-	(*ResponseCatalog)(nil),         // 60: global.ResponseCatalog
-	(*ReqRecordDelete)(nil),         // 61: global.ReqRecordDelete
-	(*ResponseDelete)(nil),          // 62: global.ResponseDelete
-	(*ReqRecordCatalog)(nil),        // 63: global.ReqRecordCatalog
-	nil,                             // 64: global.Formily.PropertiesEntry
-	nil,                             // 65: global.Formily.ComponentPropsEntry
-	nil,                             // 66: global.FormilyResponse.PropertiesEntry
-	nil,                             // 67: global.PluginInfo.DescriptionEntry
-	nil,                             // 68: global.TaskTreeData.DescriptionEntry
-	nil,                             // 69: global.StreamWaitListResponse.ListEntry
-	nil,                             // 70: global.TrackSnapShotData.ReaderEntry
-	(*timestamppb.Timestamp)(nil),   // 71: google.protobuf.Timestamp
-	(*durationpb.Duration)(nil),     // 72: google.protobuf.Duration
-	(*anypb.Any)(nil),               // 73: google.protobuf.Any
-	(*emptypb.Empty)(nil),           // 74: google.protobuf.Empty
+	(*EventRecordFile)(nil),         // 58: global.EventRecordFile
+	(*RecordResponseList)(nil),      // 59: global.RecordResponseList
+	(*EventRecordResponseList)(nil), // 60: global.EventRecordResponseList
+	(*Catalog)(nil),                 // 61: global.Catalog
+	(*ResponseCatalog)(nil),         // 62: global.ResponseCatalog
+	(*ReqRecordDelete)(nil),         // 63: global.ReqRecordDelete
+	(*ResponseDelete)(nil),          // 64: global.ResponseDelete
+	(*ReqRecordCatalog)(nil),        // 65: global.ReqRecordCatalog
+	nil,                             // 66: global.Formily.PropertiesEntry
+	nil,                             // 67: global.Formily.ComponentPropsEntry
+	nil,                             // 68: global.FormilyResponse.PropertiesEntry
+	nil,                             // 69: global.PluginInfo.DescriptionEntry
+	nil,                             // 70: global.TaskTreeData.DescriptionEntry
+	nil,                             // 71: global.StreamWaitListResponse.ListEntry
+	nil,                             // 72: global.TrackSnapShotData.ReaderEntry
+	(*timestamppb.Timestamp)(nil),   // 73: google.protobuf.Timestamp
+	(*durationpb.Duration)(nil),     // 74: google.protobuf.Duration
+	(*anypb.Any)(nil),               // 75: google.protobuf.Any
+	(*emptypb.Empty)(nil),           // 76: google.protobuf.Empty
 }
 var file_global_proto_depIdxs = []int32{
 	12,  // 0: global.DisabledPluginsResponse.data:type_name -> global.PluginInfo
-	64,  // 1: global.Formily.properties:type_name -> global.Formily.PropertiesEntry
-	65,  // 2: global.Formily.componentProps:type_name -> global.Formily.ComponentPropsEntry
-	66,  // 3: global.FormilyResponse.properties:type_name -> global.FormilyResponse.PropertiesEntry
+	66,  // 1: global.Formily.properties:type_name -> global.Formily.PropertiesEntry
+	67,  // 2: global.Formily.componentProps:type_name -> global.Formily.ComponentPropsEntry
+	68,  // 3: global.FormilyResponse.properties:type_name -> global.FormilyResponse.PropertiesEntry
 	4,   // 4: global.GetConfigResponse.data:type_name -> global.ConfigData
 	10,  // 5: global.SummaryResponse.memory:type_name -> global.Usage
 	10,  // 6: global.SummaryResponse.hardDisk:type_name -> global.Usage
 	9,   // 7: global.SummaryResponse.netWork:type_name -> global.NetWorkInfo
-	67,  // 8: global.PluginInfo.description:type_name -> global.PluginInfo.DescriptionEntry
-	71,  // 9: global.SysInfoData.startTime:type_name -> google.protobuf.Timestamp
+	69,  // 8: global.PluginInfo.description:type_name -> global.PluginInfo.DescriptionEntry
+	73,  // 9: global.SysInfoData.startTime:type_name -> google.protobuf.Timestamp
 	12,  // 10: global.SysInfoData.plugins:type_name -> global.PluginInfo
 	13,  // 11: global.SysInfoResponse.data:type_name -> global.SysInfoData
-	71,  // 12: global.TaskTreeData.startTime:type_name -> google.protobuf.Timestamp
-	68,  // 13: global.TaskTreeData.description:type_name -> global.TaskTreeData.DescriptionEntry
+	73,  // 12: global.TaskTreeData.startTime:type_name -> google.protobuf.Timestamp
+	70,  // 13: global.TaskTreeData.description:type_name -> global.TaskTreeData.DescriptionEntry
 	15,  // 14: global.TaskTreeData.children:type_name -> global.TaskTreeData
 	15,  // 15: global.TaskTreeData.blocked:type_name -> global.TaskTreeData
 	15,  // 16: global.TaskTreeResponse.data:type_name -> global.TaskTreeData
 	22,  // 17: global.StreamListResponse.data:type_name -> global.StreamInfo
-	69,  // 18: global.StreamWaitListResponse.list:type_name -> global.StreamWaitListResponse.ListEntry
+	71,  // 18: global.StreamWaitListResponse.list:type_name -> global.StreamWaitListResponse.ListEntry
 	22,  // 19: global.StreamInfoResponse.data:type_name -> global.StreamInfo
 	28,  // 20: global.StreamInfo.audioTrack:type_name -> global.AudioTrackInfo
 	31,  // 21: global.StreamInfo.videoTrack:type_name -> global.VideoTrackInfo
-	71,  // 22: global.StreamInfo.startTime:type_name -> google.protobuf.Timestamp
-	72,  // 23: global.StreamInfo.bufferTime:type_name -> google.protobuf.Duration
+	73,  // 22: global.StreamInfo.startTime:type_name -> google.protobuf.Timestamp
+	74,  // 23: global.StreamInfo.bufferTime:type_name -> google.protobuf.Duration
 	23,  // 24: global.StreamInfo.recording:type_name -> global.RecordingDetail
-	72,  // 25: global.RecordingDetail.fragment:type_name -> google.protobuf.Duration
-	71,  // 26: global.TrackSnapShot.writeTime:type_name -> google.protobuf.Timestamp
+	74,  // 25: global.RecordingDetail.fragment:type_name -> google.protobuf.Duration
+	73,  // 26: global.TrackSnapShot.writeTime:type_name -> google.protobuf.Timestamp
 	24,  // 27: global.TrackSnapShot.wrap:type_name -> global.Wrap
 	26,  // 28: global.MemoryBlockGroup.list:type_name -> global.MemoryBlock
 	25,  // 29: global.TrackSnapShotData.ring:type_name -> global.TrackSnapShot
-	70,  // 30: global.TrackSnapShotData.reader:type_name -> global.TrackSnapShotData.ReaderEntry
+	72,  // 30: global.TrackSnapShotData.reader:type_name -> global.TrackSnapShotData.ReaderEntry
 	27,  // 31: global.TrackSnapShotData.memory:type_name -> global.MemoryBlockGroup
 	29,  // 32: global.TrackSnapShotResponse.data:type_name -> global.TrackSnapShotData
-	71,  // 33: global.SubscriberSnapShot.startTime:type_name -> google.protobuf.Timestamp
+	73,  // 33: global.SubscriberSnapShot.startTime:type_name -> google.protobuf.Timestamp
 	37,  // 34: global.SubscriberSnapShot.audioReader:type_name -> global.RingReaderSnapShot
 	37,  // 35: global.SubscriberSnapShot.videoReader:type_name -> global.RingReaderSnapShot
-	72,  // 36: global.SubscriberSnapShot.bufferTime:type_name -> google.protobuf.Duration
+	74,  // 36: global.SubscriberSnapShot.bufferTime:type_name -> google.protobuf.Duration
 	38,  // 37: global.SubscribersResponse.data:type_name -> global.SubscriberSnapShot
 	41,  // 38: global.PullProxyListResponse.data:type_name -> global.PullProxyInfo
-	71,  // 39: global.PullProxyInfo.createTime:type_name -> google.protobuf.Timestamp
-	71,  // 40: global.PullProxyInfo.updateTime:type_name -> google.protobuf.Timestamp
-	72,  // 41: global.PullProxyInfo.recordFragment:type_name -> google.protobuf.Duration
-	71,  // 42: global.PushProxyInfo.createTime:type_name -> google.protobuf.Timestamp
-	71,  // 43: global.PushProxyInfo.updateTime:type_name -> google.protobuf.Timestamp
+	73,  // 39: global.PullProxyInfo.createTime:type_name -> google.protobuf.Timestamp
+	73,  // 40: global.PullProxyInfo.updateTime:type_name -> google.protobuf.Timestamp
+	74,  // 41: global.PullProxyInfo.recordFragment:type_name -> google.protobuf.Duration
+	73,  // 42: global.PushProxyInfo.createTime:type_name -> google.protobuf.Timestamp
+	73,  // 43: global.PushProxyInfo.updateTime:type_name -> google.protobuf.Timestamp
 	42,  // 44: global.PushProxyListResponse.data:type_name -> global.PushProxyInfo
 	45,  // 45: global.StreamAliasListResponse.data:type_name -> global.StreamAlias
-	71,  // 46: global.Recording.startTime:type_name -> google.protobuf.Timestamp
+	73,  // 46: global.Recording.startTime:type_name -> google.protobuf.Timestamp
 	49,  // 47: global.RecordingListResponse.data:type_name -> global.Recording
-	71,  // 48: global.PushInfo.startTime:type_name -> google.protobuf.Timestamp
+	73,  // 48: global.PushInfo.startTime:type_name -> google.protobuf.Timestamp
 	51,  // 49: global.PushListResponse.data:type_name -> global.PushInfo
 	54,  // 50: global.TransformListResponse.data:type_name -> global.Transform
-	71,  // 51: global.RecordFile.startTime:type_name -> google.protobuf.Timestamp
-	71,  // 52: global.RecordFile.endTime:type_name -> google.protobuf.Timestamp
-	57,  // 53: global.ResponseList.data:type_name -> global.RecordFile
-	71,  // 54: global.Catalog.startTime:type_name -> google.protobuf.Timestamp
-	71,  // 55: global.Catalog.endTime:type_name -> google.protobuf.Timestamp
-	59,  // 56: global.ResponseCatalog.data:type_name -> global.Catalog
-	57,  // 57: global.ResponseDelete.data:type_name -> global.RecordFile
-	2,   // 58: global.Formily.PropertiesEntry.value:type_name -> global.Formily
-	73,  // 59: global.Formily.ComponentPropsEntry.value:type_name -> google.protobuf.Any
-	2,   // 60: global.FormilyResponse.PropertiesEntry.value:type_name -> global.Formily
-	74,  // 61: global.api.SysInfo:input_type -> google.protobuf.Empty
-	74,  // 62: global.api.DisabledPlugins:input_type -> google.protobuf.Empty
-	74,  // 63: global.api.Summary:input_type -> google.protobuf.Empty
-	33,  // 64: global.api.Shutdown:input_type -> global.RequestWithId
-	33,  // 65: global.api.Restart:input_type -> global.RequestWithId
-	74,  // 66: global.api.TaskTree:input_type -> google.protobuf.Empty
-	34,  // 67: global.api.StopTask:input_type -> global.RequestWithId64
-	34,  // 68: global.api.RestartTask:input_type -> global.RequestWithId64
-	17,  // 69: global.api.StreamList:input_type -> global.StreamListRequest
-	74,  // 70: global.api.WaitList:input_type -> google.protobuf.Empty
-	20,  // 71: global.api.StreamInfo:input_type -> global.StreamSnapRequest
-	20,  // 72: global.api.PauseStream:input_type -> global.StreamSnapRequest
-	20,  // 73: global.api.ResumeStream:input_type -> global.StreamSnapRequest
-	47,  // 74: global.api.SetStreamSpeed:input_type -> global.SetStreamSpeedRequest
-	48,  // 75: global.api.SeekStream:input_type -> global.SeekStreamRequest
-	36,  // 76: global.api.GetSubscribers:input_type -> global.SubscribersRequest
-	20,  // 77: global.api.AudioTrackSnap:input_type -> global.StreamSnapRequest
-	20,  // 78: global.api.VideoTrackSnap:input_type -> global.StreamSnapRequest
-	35,  // 79: global.api.ChangeSubscribe:input_type -> global.ChangeSubscribeRequest
-	74,  // 80: global.api.GetStreamAlias:input_type -> google.protobuf.Empty
-	44,  // 81: global.api.SetStreamAlias:input_type -> global.SetStreamAliasRequest
-	20,  // 82: global.api.StopPublish:input_type -> global.StreamSnapRequest
-	33,  // 83: global.api.StopSubscribe:input_type -> global.RequestWithId
-	74,  // 84: global.api.GetConfigFile:input_type -> google.protobuf.Empty
-	7,   // 85: global.api.UpdateConfigFile:input_type -> global.UpdateConfigFileRequest
-	1,   // 86: global.api.GetConfig:input_type -> global.GetConfigRequest
-	1,   // 87: global.api.GetFormily:input_type -> global.GetConfigRequest
-	74,  // 88: global.api.GetPullProxyList:input_type -> google.protobuf.Empty
-	41,  // 89: global.api.AddPullProxy:input_type -> global.PullProxyInfo
-	33,  // 90: global.api.RemovePullProxy:input_type -> global.RequestWithId
-	41,  // 91: global.api.UpdatePullProxy:input_type -> global.PullProxyInfo
-	74,  // 92: global.api.GetPushProxyList:input_type -> google.protobuf.Empty
-	42,  // 93: global.api.AddPushProxy:input_type -> global.PushProxyInfo
-	33,  // 94: global.api.RemovePushProxy:input_type -> global.RequestWithId
-	42,  // 95: global.api.UpdatePushProxy:input_type -> global.PushProxyInfo
-	74,  // 96: global.api.GetRecording:input_type -> google.protobuf.Empty
-	74,  // 97: global.api.GetTransformList:input_type -> google.protobuf.Empty
-	56,  // 98: global.api.GetRecordList:input_type -> global.ReqRecordList
-	63,  // 99: global.api.GetRecordCatalog:input_type -> global.ReqRecordCatalog
-	61,  // 100: global.api.DeleteRecord:input_type -> global.ReqRecordDelete
-	14,  // 101: global.api.SysInfo:output_type -> global.SysInfoResponse
-	0,   // 102: global.api.DisabledPlugins:output_type -> global.DisabledPluginsResponse
-	11,  // 103: global.api.Summary:output_type -> global.SummaryResponse
-	32,  // 104: global.api.Shutdown:output_type -> global.SuccessResponse
-	32,  // 105: global.api.Restart:output_type -> global.SuccessResponse
-	16,  // 106: global.api.TaskTree:output_type -> global.TaskTreeResponse
-	32,  // 107: global.api.StopTask:output_type -> global.SuccessResponse
-	32,  // 108: global.api.RestartTask:output_type -> global.SuccessResponse
-	18,  // 109: global.api.StreamList:output_type -> global.StreamListResponse
-	19,  // 110: global.api.WaitList:output_type -> global.StreamWaitListResponse
-	21,  // 111: global.api.StreamInfo:output_type -> global.StreamInfoResponse
-	32,  // 112: global.api.PauseStream:output_type -> global.SuccessResponse
-	32,  // 113: global.api.ResumeStream:output_type -> global.SuccessResponse
-	32,  // 114: global.api.SetStreamSpeed:output_type -> global.SuccessResponse
-	32,  // 115: global.api.SeekStream:output_type -> global.SuccessResponse
-	39,  // 116: global.api.GetSubscribers:output_type -> global.SubscribersResponse
-	30,  // 117: global.api.AudioTrackSnap:output_type -> global.TrackSnapShotResponse
-	30,  // 118: global.api.VideoTrackSnap:output_type -> global.TrackSnapShotResponse
-	32,  // 119: global.api.ChangeSubscribe:output_type -> global.SuccessResponse
-	46,  // 120: global.api.GetStreamAlias:output_type -> global.StreamAliasListResponse
-	32,  // 121: global.api.SetStreamAlias:output_type -> global.SuccessResponse
-	32,  // 122: global.api.StopPublish:output_type -> global.SuccessResponse
-	32,  // 123: global.api.StopSubscribe:output_type -> global.SuccessResponse
-	5,   // 124: global.api.GetConfigFile:output_type -> global.GetConfigFileResponse
-	32,  // 125: global.api.UpdateConfigFile:output_type -> global.SuccessResponse
-	6,   // 126: global.api.GetConfig:output_type -> global.GetConfigResponse
-	6,   // 127: global.api.GetFormily:output_type -> global.GetConfigResponse
-	40,  // 128: global.api.GetPullProxyList:output_type -> global.PullProxyListResponse
-	32,  // 129: global.api.AddPullProxy:output_type -> global.SuccessResponse
-	32,  // 130: global.api.RemovePullProxy:output_type -> global.SuccessResponse
-	32,  // 131: global.api.UpdatePullProxy:output_type -> global.SuccessResponse
-	43,  // 132: global.api.GetPushProxyList:output_type -> global.PushProxyListResponse
-	32,  // 133: global.api.AddPushProxy:output_type -> global.SuccessResponse
-	32,  // 134: global.api.RemovePushProxy:output_type -> global.SuccessResponse
-	32,  // 135: global.api.UpdatePushProxy:output_type -> global.SuccessResponse
-	50,  // 136: global.api.GetRecording:output_type -> global.RecordingListResponse
-	55,  // 137: global.api.GetTransformList:output_type -> global.TransformListResponse
-	58,  // 138: global.api.GetRecordList:output_type -> global.ResponseList
-	60,  // 139: global.api.GetRecordCatalog:output_type -> global.ResponseCatalog
-	62,  // 140: global.api.DeleteRecord:output_type -> global.ResponseDelete
-	101, // [101:141] is the sub-list for method output_type
-	61,  // [61:101] is the sub-list for method input_type
-	61,  // [61:61] is the sub-list for extension type_name
-	61,  // [61:61] is the sub-list for extension extendee
-	0,   // [0:61] is the sub-list for field type_name
+	73,  // 51: global.RecordFile.startTime:type_name -> google.protobuf.Timestamp
+	73,  // 52: global.RecordFile.endTime:type_name -> google.protobuf.Timestamp
+	73,  // 53: global.EventRecordFile.startTime:type_name -> google.protobuf.Timestamp
+	73,  // 54: global.EventRecordFile.endTime:type_name -> google.protobuf.Timestamp
+	57,  // 55: global.RecordResponseList.data:type_name -> global.RecordFile
+	58,  // 56: global.EventRecordResponseList.data:type_name -> global.EventRecordFile
+	73,  // 57: global.Catalog.startTime:type_name -> google.protobuf.Timestamp
+	73,  // 58: global.Catalog.endTime:type_name -> google.protobuf.Timestamp
+	61,  // 59: global.ResponseCatalog.data:type_name -> global.Catalog
+	57,  // 60: global.ResponseDelete.data:type_name -> global.RecordFile
+	2,   // 61: global.Formily.PropertiesEntry.value:type_name -> global.Formily
+	75,  // 62: global.Formily.ComponentPropsEntry.value:type_name -> google.protobuf.Any
+	2,   // 63: global.FormilyResponse.PropertiesEntry.value:type_name -> global.Formily
+	76,  // 64: global.api.SysInfo:input_type -> google.protobuf.Empty
+	76,  // 65: global.api.DisabledPlugins:input_type -> google.protobuf.Empty
+	76,  // 66: global.api.Summary:input_type -> google.protobuf.Empty
+	33,  // 67: global.api.Shutdown:input_type -> global.RequestWithId
+	33,  // 68: global.api.Restart:input_type -> global.RequestWithId
+	76,  // 69: global.api.TaskTree:input_type -> google.protobuf.Empty
+	34,  // 70: global.api.StopTask:input_type -> global.RequestWithId64
+	34,  // 71: global.api.RestartTask:input_type -> global.RequestWithId64
+	17,  // 72: global.api.StreamList:input_type -> global.StreamListRequest
+	76,  // 73: global.api.WaitList:input_type -> google.protobuf.Empty
+	20,  // 74: global.api.StreamInfo:input_type -> global.StreamSnapRequest
+	20,  // 75: global.api.PauseStream:input_type -> global.StreamSnapRequest
+	20,  // 76: global.api.ResumeStream:input_type -> global.StreamSnapRequest
+	47,  // 77: global.api.SetStreamSpeed:input_type -> global.SetStreamSpeedRequest
+	48,  // 78: global.api.SeekStream:input_type -> global.SeekStreamRequest
+	36,  // 79: global.api.GetSubscribers:input_type -> global.SubscribersRequest
+	20,  // 80: global.api.AudioTrackSnap:input_type -> global.StreamSnapRequest
+	20,  // 81: global.api.VideoTrackSnap:input_type -> global.StreamSnapRequest
+	35,  // 82: global.api.ChangeSubscribe:input_type -> global.ChangeSubscribeRequest
+	76,  // 83: global.api.GetStreamAlias:input_type -> google.protobuf.Empty
+	44,  // 84: global.api.SetStreamAlias:input_type -> global.SetStreamAliasRequest
+	20,  // 85: global.api.StopPublish:input_type -> global.StreamSnapRequest
+	33,  // 86: global.api.StopSubscribe:input_type -> global.RequestWithId
+	76,  // 87: global.api.GetConfigFile:input_type -> google.protobuf.Empty
+	7,   // 88: global.api.UpdateConfigFile:input_type -> global.UpdateConfigFileRequest
+	1,   // 89: global.api.GetConfig:input_type -> global.GetConfigRequest
+	1,   // 90: global.api.GetFormily:input_type -> global.GetConfigRequest
+	76,  // 91: global.api.GetPullProxyList:input_type -> google.protobuf.Empty
+	41,  // 92: global.api.AddPullProxy:input_type -> global.PullProxyInfo
+	33,  // 93: global.api.RemovePullProxy:input_type -> global.RequestWithId
+	41,  // 94: global.api.UpdatePullProxy:input_type -> global.PullProxyInfo
+	76,  // 95: global.api.GetPushProxyList:input_type -> google.protobuf.Empty
+	42,  // 96: global.api.AddPushProxy:input_type -> global.PushProxyInfo
+	33,  // 97: global.api.RemovePushProxy:input_type -> global.RequestWithId
+	42,  // 98: global.api.UpdatePushProxy:input_type -> global.PushProxyInfo
+	76,  // 99: global.api.GetRecording:input_type -> google.protobuf.Empty
+	76,  // 100: global.api.GetTransformList:input_type -> google.protobuf.Empty
+	56,  // 101: global.api.GetRecordList:input_type -> global.ReqRecordList
+	56,  // 102: global.api.GetEventRecordList:input_type -> global.ReqRecordList
+	65,  // 103: global.api.GetRecordCatalog:input_type -> global.ReqRecordCatalog
+	63,  // 104: global.api.DeleteRecord:input_type -> global.ReqRecordDelete
+	14,  // 105: global.api.SysInfo:output_type -> global.SysInfoResponse
+	0,   // 106: global.api.DisabledPlugins:output_type -> global.DisabledPluginsResponse
+	11,  // 107: global.api.Summary:output_type -> global.SummaryResponse
+	32,  // 108: global.api.Shutdown:output_type -> global.SuccessResponse
+	32,  // 109: global.api.Restart:output_type -> global.SuccessResponse
+	16,  // 110: global.api.TaskTree:output_type -> global.TaskTreeResponse
+	32,  // 111: global.api.StopTask:output_type -> global.SuccessResponse
+	32,  // 112: global.api.RestartTask:output_type -> global.SuccessResponse
+	18,  // 113: global.api.StreamList:output_type -> global.StreamListResponse
+	19,  // 114: global.api.WaitList:output_type -> global.StreamWaitListResponse
+	21,  // 115: global.api.StreamInfo:output_type -> global.StreamInfoResponse
+	32,  // 116: global.api.PauseStream:output_type -> global.SuccessResponse
+	32,  // 117: global.api.ResumeStream:output_type -> global.SuccessResponse
+	32,  // 118: global.api.SetStreamSpeed:output_type -> global.SuccessResponse
+	32,  // 119: global.api.SeekStream:output_type -> global.SuccessResponse
+	39,  // 120: global.api.GetSubscribers:output_type -> global.SubscribersResponse
+	30,  // 121: global.api.AudioTrackSnap:output_type -> global.TrackSnapShotResponse
+	30,  // 122: global.api.VideoTrackSnap:output_type -> global.TrackSnapShotResponse
+	32,  // 123: global.api.ChangeSubscribe:output_type -> global.SuccessResponse
+	46,  // 124: global.api.GetStreamAlias:output_type -> global.StreamAliasListResponse
+	32,  // 125: global.api.SetStreamAlias:output_type -> global.SuccessResponse
+	32,  // 126: global.api.StopPublish:output_type -> global.SuccessResponse
+	32,  // 127: global.api.StopSubscribe:output_type -> global.SuccessResponse
+	5,   // 128: global.api.GetConfigFile:output_type -> global.GetConfigFileResponse
+	32,  // 129: global.api.UpdateConfigFile:output_type -> global.SuccessResponse
+	6,   // 130: global.api.GetConfig:output_type -> global.GetConfigResponse
+	6,   // 131: global.api.GetFormily:output_type -> global.GetConfigResponse
+	40,  // 132: global.api.GetPullProxyList:output_type -> global.PullProxyListResponse
+	32,  // 133: global.api.AddPullProxy:output_type -> global.SuccessResponse
+	32,  // 134: global.api.RemovePullProxy:output_type -> global.SuccessResponse
+	32,  // 135: global.api.UpdatePullProxy:output_type -> global.SuccessResponse
+	43,  // 136: global.api.GetPushProxyList:output_type -> global.PushProxyListResponse
+	32,  // 137: global.api.AddPushProxy:output_type -> global.SuccessResponse
+	32,  // 138: global.api.RemovePushProxy:output_type -> global.SuccessResponse
+	32,  // 139: global.api.UpdatePushProxy:output_type -> global.SuccessResponse
+	50,  // 140: global.api.GetRecording:output_type -> global.RecordingListResponse
+	55,  // 141: global.api.GetTransformList:output_type -> global.TransformListResponse
+	59,  // 142: global.api.GetRecordList:output_type -> global.RecordResponseList
+	60,  // 143: global.api.GetEventRecordList:output_type -> global.EventRecordResponseList
+	62,  // 144: global.api.GetRecordCatalog:output_type -> global.ResponseCatalog
+	64,  // 145: global.api.DeleteRecord:output_type -> global.ResponseDelete
+	105, // [105:146] is the sub-list for method output_type
+	64,  // [64:105] is the sub-list for method input_type
+	64,  // [64:64] is the sub-list for extension type_name
+	64,  // [64:64] is the sub-list for extension extendee
+	0,   // [0:64] is the sub-list for field type_name
 }
 
 func init() { file_global_proto_init() }
@@ -5373,7 +5556,7 @@ func file_global_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: unsafe.Slice(unsafe.StringData(file_global_proto_rawDesc), len(file_global_proto_rawDesc)),
 			NumEnums:      0,
-			NumMessages:   71,
+			NumMessages:   73,
 			NumExtensions: 0,
 			NumServices:   1,
 		},

pb/global.pb.gw.go

@@ -1708,6 +1708,96 @@ func local_request_Api_GetRecordList_0(ctx context.Context, marshaler runtime.Ma
 
 }
 
+var (
+	filter_Api_GetEventRecordList_0 = &utilities.DoubleArray{Encoding: map[string]int{"type": 0, "streamPath": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
+)
+
+func request_Api_GetEventRecordList_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq ReqRecordList
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["type"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "type")
+	}
+
+	protoReq.Type, err = runtime.String(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "type", err)
+	}
+
+	val, ok = pathParams["streamPath"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "streamPath")
+	}
+
+	protoReq.StreamPath, err = runtime.String(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "streamPath", err)
+	}
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetEventRecordList_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.GetEventRecordList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Api_GetEventRecordList_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq ReqRecordList
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["type"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "type")
+	}
+
+	protoReq.Type, err = runtime.String(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "type", err)
+	}
+
+	val, ok = pathParams["streamPath"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "streamPath")
+	}
+
+	protoReq.StreamPath, err = runtime.String(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "streamPath", err)
+	}
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetEventRecordList_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.GetEventRecordList(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 func request_Api_GetRecordCatalog_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
 	var protoReq ReqRecordCatalog
 	var metadata runtime.ServerMetadata
@@ -2896,6 +2986,31 @@ func RegisterApiHandlerServer(ctx context.Context, mux *runtime.ServeMux, server
 
 	})
 
+	mux.Handle("GET", pattern_Api_GetEventRecordList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		var err error
+		var annotatedContext context.Context
+		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/global.Api/GetEventRecordList", runtime.WithHTTPPathPattern("/api/record/{type}/event/list/{streamPath=**}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Api_GetEventRecordList_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Api_GetEventRecordList_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_Api_GetRecordCatalog_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -3911,6 +4026,28 @@ func RegisterApiHandlerClient(ctx context.Context, mux *runtime.ServeMux, client
 
 	})
 
+	mux.Handle("GET", pattern_Api_GetEventRecordList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		var err error
+		var annotatedContext context.Context
+		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/global.Api/GetEventRecordList", runtime.WithHTTPPathPattern("/api/record/{type}/event/list/{streamPath=**}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Api_GetEventRecordList_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Api_GetEventRecordList_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_Api_GetRecordCatalog_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -4043,6 +4180,8 @@ var (
 
 	pattern_Api_GetRecordList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3, 3, 0, 4, 1, 5, 4}, []string{"api", "record", "type", "list", "streamPath"}, ""))
 
+	pattern_Api_GetEventRecordList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3, 2, 4, 3, 0, 4, 1, 5, 5}, []string{"api", "record", "type", "event", "list", "streamPath"}, ""))
+
 	pattern_Api_GetRecordCatalog_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3}, []string{"api", "record", "type", "catalog"}, ""))
 
 	pattern_Api_DeleteRecord_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3, 3, 0, 4, 1, 5, 4}, []string{"api", "record", "type", "delete", "streamPath"}, ""))
@@ -4133,6 +4272,8 @@ var (
 
 	forward_Api_GetRecordList_0 = runtime.ForwardResponseMessage
 
+	forward_Api_GetEventRecordList_0 = runtime.ForwardResponseMessage
+
 	forward_Api_GetRecordCatalog_0 = runtime.ForwardResponseMessage
 
 	forward_Api_DeleteRecord_0 = runtime.ForwardResponseMessage

pb/global.proto

@@ -224,11 +224,16 @@ service api {
       get: "/api/transform/list"
     };
   }
-  rpc GetRecordList (ReqRecordList) returns (ResponseList) {
+  rpc GetRecordList (ReqRecordList) returns (RecordResponseList) {
     option (google.api.http) = {
       get: "/api/record/{type}/list/{streamPath=**}"
     };
   }
+  rpc GetEventRecordList (ReqRecordList) returns (EventRecordResponseList) {
+    option (google.api.http) = {
+      get: "/api/record/{type}/event/list/{streamPath=**}"
+    };
+  }
   rpc GetRecordCatalog (ReqRecordCatalog) returns (ResponseCatalog) {
     option (google.api.http) = {
       get: "/api/record/{type}/catalog"
@@ -664,9 +669,8 @@ message ReqRecordList {
   string end = 4;
   uint32 pageNum = 5;
   uint32 pageSize = 6;
-  string mode = 7;
-  string type = 8;
-  string eventLevel = 9;
+  string type = 7;
+  string eventLevel = 8;
 }
 
 message RecordFile {
@@ -675,12 +679,21 @@ message RecordFile {
   string streamPath = 3;
   google.protobuf.Timestamp startTime = 4;
   google.protobuf.Timestamp endTime = 5;
-  string eventLevel = 6;
-  string eventName = 7;
-  string eventDesc = 8;
 }
 
-message ResponseList {
+message EventRecordFile {
+  uint32 id = 1;
+  string filePath = 2;
+  string streamPath = 3;
+  google.protobuf.Timestamp startTime = 4;
+  google.protobuf.Timestamp endTime = 5;
+  string eventId = 6;
+  string eventLevel = 7;
+  string eventName = 8;
+  string eventDesc = 9;
+}
+
+message RecordResponseList {
   int32 code = 1;
   string message = 2;
   uint32 total = 3;
@@ -689,6 +702,15 @@ message ResponseList {
   repeated RecordFile data = 6;
 }
 
+message EventRecordResponseList {
+  int32 code = 1;
+  string message = 2;
+  uint32 total = 3;
+  uint32 pageNum = 4;
+  uint32 pageSize = 5;
+  repeated EventRecordFile data = 6;
+}
+
 message Catalog {
   string streamPath = 1;
   uint32 count = 2;

pb/global_grpc.pb.go

@@ -20,46 +20,47 @@ import (
 const _ = grpc.SupportPackageIsVersion9
 
 const (
-	Api_SysInfo_FullMethodName          = "/global.api/SysInfo"
-	Api_DisabledPlugins_FullMethodName  = "/global.api/DisabledPlugins"
-	Api_Summary_FullMethodName          = "/global.api/Summary"
-	Api_Shutdown_FullMethodName         = "/global.api/Shutdown"
-	Api_Restart_FullMethodName          = "/global.api/Restart"
-	Api_TaskTree_FullMethodName         = "/global.api/TaskTree"
-	Api_StopTask_FullMethodName         = "/global.api/StopTask"
-	Api_RestartTask_FullMethodName      = "/global.api/RestartTask"
-	Api_StreamList_FullMethodName       = "/global.api/StreamList"
-	Api_WaitList_FullMethodName         = "/global.api/WaitList"
-	Api_StreamInfo_FullMethodName       = "/global.api/StreamInfo"
-	Api_PauseStream_FullMethodName      = "/global.api/PauseStream"
-	Api_ResumeStream_FullMethodName     = "/global.api/ResumeStream"
-	Api_SetStreamSpeed_FullMethodName   = "/global.api/SetStreamSpeed"
-	Api_SeekStream_FullMethodName       = "/global.api/SeekStream"
-	Api_GetSubscribers_FullMethodName   = "/global.api/GetSubscribers"
-	Api_AudioTrackSnap_FullMethodName   = "/global.api/AudioTrackSnap"
-	Api_VideoTrackSnap_FullMethodName   = "/global.api/VideoTrackSnap"
-	Api_ChangeSubscribe_FullMethodName  = "/global.api/ChangeSubscribe"
-	Api_GetStreamAlias_FullMethodName   = "/global.api/GetStreamAlias"
-	Api_SetStreamAlias_FullMethodName   = "/global.api/SetStreamAlias"
-	Api_StopPublish_FullMethodName      = "/global.api/StopPublish"
-	Api_StopSubscribe_FullMethodName    = "/global.api/StopSubscribe"
-	Api_GetConfigFile_FullMethodName    = "/global.api/GetConfigFile"
-	Api_UpdateConfigFile_FullMethodName = "/global.api/UpdateConfigFile"
-	Api_GetConfig_FullMethodName        = "/global.api/GetConfig"
-	Api_GetFormily_FullMethodName       = "/global.api/GetFormily"
-	Api_GetPullProxyList_FullMethodName = "/global.api/GetPullProxyList"
-	Api_AddPullProxy_FullMethodName     = "/global.api/AddPullProxy"
-	Api_RemovePullProxy_FullMethodName  = "/global.api/RemovePullProxy"
-	Api_UpdatePullProxy_FullMethodName  = "/global.api/UpdatePullProxy"
-	Api_GetPushProxyList_FullMethodName = "/global.api/GetPushProxyList"
-	Api_AddPushProxy_FullMethodName     = "/global.api/AddPushProxy"
-	Api_RemovePushProxy_FullMethodName  = "/global.api/RemovePushProxy"
-	Api_UpdatePushProxy_FullMethodName  = "/global.api/UpdatePushProxy"
-	Api_GetRecording_FullMethodName     = "/global.api/GetRecording"
-	Api_GetTransformList_FullMethodName = "/global.api/GetTransformList"
-	Api_GetRecordList_FullMethodName    = "/global.api/GetRecordList"
-	Api_GetRecordCatalog_FullMethodName = "/global.api/GetRecordCatalog"
-	Api_DeleteRecord_FullMethodName     = "/global.api/DeleteRecord"
+	Api_SysInfo_FullMethodName            = "/global.api/SysInfo"
+	Api_DisabledPlugins_FullMethodName    = "/global.api/DisabledPlugins"
+	Api_Summary_FullMethodName            = "/global.api/Summary"
+	Api_Shutdown_FullMethodName           = "/global.api/Shutdown"
+	Api_Restart_FullMethodName            = "/global.api/Restart"
+	Api_TaskTree_FullMethodName           = "/global.api/TaskTree"
+	Api_StopTask_FullMethodName           = "/global.api/StopTask"
+	Api_RestartTask_FullMethodName        = "/global.api/RestartTask"
+	Api_StreamList_FullMethodName         = "/global.api/StreamList"
+	Api_WaitList_FullMethodName           = "/global.api/WaitList"
+	Api_StreamInfo_FullMethodName         = "/global.api/StreamInfo"
+	Api_PauseStream_FullMethodName        = "/global.api/PauseStream"
+	Api_ResumeStream_FullMethodName       = "/global.api/ResumeStream"
+	Api_SetStreamSpeed_FullMethodName     = "/global.api/SetStreamSpeed"
+	Api_SeekStream_FullMethodName         = "/global.api/SeekStream"
+	Api_GetSubscribers_FullMethodName     = "/global.api/GetSubscribers"
+	Api_AudioTrackSnap_FullMethodName     = "/global.api/AudioTrackSnap"
+	Api_VideoTrackSnap_FullMethodName     = "/global.api/VideoTrackSnap"
+	Api_ChangeSubscribe_FullMethodName    = "/global.api/ChangeSubscribe"
+	Api_GetStreamAlias_FullMethodName     = "/global.api/GetStreamAlias"
+	Api_SetStreamAlias_FullMethodName     = "/global.api/SetStreamAlias"
+	Api_StopPublish_FullMethodName        = "/global.api/StopPublish"
+	Api_StopSubscribe_FullMethodName      = "/global.api/StopSubscribe"
+	Api_GetConfigFile_FullMethodName      = "/global.api/GetConfigFile"
+	Api_UpdateConfigFile_FullMethodName   = "/global.api/UpdateConfigFile"
+	Api_GetConfig_FullMethodName          = "/global.api/GetConfig"
+	Api_GetFormily_FullMethodName         = "/global.api/GetFormily"
+	Api_GetPullProxyList_FullMethodName   = "/global.api/GetPullProxyList"
+	Api_AddPullProxy_FullMethodName       = "/global.api/AddPullProxy"
+	Api_RemovePullProxy_FullMethodName    = "/global.api/RemovePullProxy"
+	Api_UpdatePullProxy_FullMethodName    = "/global.api/UpdatePullProxy"
+	Api_GetPushProxyList_FullMethodName   = "/global.api/GetPushProxyList"
+	Api_AddPushProxy_FullMethodName       = "/global.api/AddPushProxy"
+	Api_RemovePushProxy_FullMethodName    = "/global.api/RemovePushProxy"
+	Api_UpdatePushProxy_FullMethodName    = "/global.api/UpdatePushProxy"
+	Api_GetRecording_FullMethodName       = "/global.api/GetRecording"
+	Api_GetTransformList_FullMethodName   = "/global.api/GetTransformList"
+	Api_GetRecordList_FullMethodName      = "/global.api/GetRecordList"
+	Api_GetEventRecordList_FullMethodName = "/global.api/GetEventRecordList"
+	Api_GetRecordCatalog_FullMethodName   = "/global.api/GetRecordCatalog"
+	Api_DeleteRecord_FullMethodName       = "/global.api/DeleteRecord"
 )
 
 // ApiClient is the client API for Api service.
@@ -103,7 +104,8 @@ type ApiClient interface {
 	UpdatePushProxy(ctx context.Context, in *PushProxyInfo, opts ...grpc.CallOption) (*SuccessResponse, error)
 	GetRecording(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*RecordingListResponse, error)
 	GetTransformList(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*TransformListResponse, error)
-	GetRecordList(ctx context.Context, in *ReqRecordList, opts ...grpc.CallOption) (*ResponseList, error)
+	GetRecordList(ctx context.Context, in *ReqRecordList, opts ...grpc.CallOption) (*RecordResponseList, error)
+	GetEventRecordList(ctx context.Context, in *ReqRecordList, opts ...grpc.CallOption) (*EventRecordResponseList, error)
 	GetRecordCatalog(ctx context.Context, in *ReqRecordCatalog, opts ...grpc.CallOption) (*ResponseCatalog, error)
 	DeleteRecord(ctx context.Context, in *ReqRecordDelete, opts ...grpc.CallOption) (*ResponseDelete, error)
 }
@@ -486,9 +488,9 @@ func (c *apiClient) GetTransformList(ctx context.Context, in *emptypb.Empty, opt
 	return out, nil
 }
 
-func (c *apiClient) GetRecordList(ctx context.Context, in *ReqRecordList, opts ...grpc.CallOption) (*ResponseList, error) {
+func (c *apiClient) GetRecordList(ctx context.Context, in *ReqRecordList, opts ...grpc.CallOption) (*RecordResponseList, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	out := new(ResponseList)
+	out := new(RecordResponseList)
 	err := c.cc.Invoke(ctx, Api_GetRecordList_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
@@ -496,6 +498,16 @@ func (c *apiClient) GetRecordList(ctx context.Context, in *ReqRecordList, opts .
 	return out, nil
 }
 
+func (c *apiClient) GetEventRecordList(ctx context.Context, in *ReqRecordList, opts ...grpc.CallOption) (*EventRecordResponseList, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(EventRecordResponseList)
+	err := c.cc.Invoke(ctx, Api_GetEventRecordList_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *apiClient) GetRecordCatalog(ctx context.Context, in *ReqRecordCatalog, opts ...grpc.CallOption) (*ResponseCatalog, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(ResponseCatalog)
@@ -557,7 +569,8 @@ type ApiServer interface {
 	UpdatePushProxy(context.Context, *PushProxyInfo) (*SuccessResponse, error)
 	GetRecording(context.Context, *emptypb.Empty) (*RecordingListResponse, error)
 	GetTransformList(context.Context, *emptypb.Empty) (*TransformListResponse, error)
-	GetRecordList(context.Context, *ReqRecordList) (*ResponseList, error)
+	GetRecordList(context.Context, *ReqRecordList) (*RecordResponseList, error)
+	GetEventRecordList(context.Context, *ReqRecordList) (*EventRecordResponseList, error)
 	GetRecordCatalog(context.Context, *ReqRecordCatalog) (*ResponseCatalog, error)
 	DeleteRecord(context.Context, *ReqRecordDelete) (*ResponseDelete, error)
 	mustEmbedUnimplementedApiServer()
@@ -681,9 +694,12 @@ func (UnimplementedApiServer) GetRecording(context.Context, *emptypb.Empty) (*Re
 func (UnimplementedApiServer) GetTransformList(context.Context, *emptypb.Empty) (*TransformListResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetTransformList not implemented")
 }
-func (UnimplementedApiServer) GetRecordList(context.Context, *ReqRecordList) (*ResponseList, error) {
+func (UnimplementedApiServer) GetRecordList(context.Context, *ReqRecordList) (*RecordResponseList, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetRecordList not implemented")
 }
+func (UnimplementedApiServer) GetEventRecordList(context.Context, *ReqRecordList) (*EventRecordResponseList, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetEventRecordList not implemented")
+}
 func (UnimplementedApiServer) GetRecordCatalog(context.Context, *ReqRecordCatalog) (*ResponseCatalog, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetRecordCatalog not implemented")
 }
@@ -1395,6 +1411,24 @@ func _Api_GetRecordList_Handler(srv interface{}, ctx context.Context, dec func(i
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Api_GetEventRecordList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ReqRecordList)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ApiServer).GetEventRecordList(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Api_GetEventRecordList_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ApiServer).GetEventRecordList(ctx, req.(*ReqRecordList))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Api_GetRecordCatalog_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(ReqRecordCatalog)
 	if err := dec(in); err != nil {
@@ -1590,6 +1624,10 @@ var Api_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "GetRecordList",
 			Handler:    _Api_GetRecordList_Handler,
 		},
+		{
+			MethodName: "GetEventRecordList",
+			Handler:    _Api_GetEventRecordList_Handler,
+		},
 		{
 			MethodName: "GetRecordCatalog",
 			Handler:    _Api_GetRecordCatalog_Handler,

pkg/avframe.go

@@ -65,8 +65,6 @@ type (
 	}
 )
 
-var _ IAVFrame = (*AnnexB)(nil)
-
 func (frame *AVFrame) Clone() {
 
 }

pkg/avframe_convert.go

@@ -0,0 +1,74 @@
+package pkg
+
+import (
+	"reflect"
+
+	"m7s.live/v5/pkg/codec"
+	"m7s.live/v5/pkg/util"
+)
+
+type AVFrameConvert[T IAVFrame] struct {
+	FromTrack, ToTrack *AVTrack
+	lastFromCodecCtx   codec.ICodecCtx
+}
+
+func NewAVFrameConvert[T IAVFrame](fromTrack *AVTrack, toTrack *AVTrack) *AVFrameConvert[T] {
+	ret := &AVFrameConvert[T]{}
+	ret.FromTrack = fromTrack
+	ret.ToTrack = toTrack
+	if ret.FromTrack == nil {
+		ret.FromTrack = &AVTrack{
+			RingWriter: &RingWriter{
+				Ring: util.NewRing[AVFrame](1),
+			},
+		}
+	}
+	if ret.ToTrack == nil {
+		ret.ToTrack = &AVTrack{
+			RingWriter: &RingWriter{
+				Ring: util.NewRing[AVFrame](1),
+			},
+		}
+		var to T
+		ret.ToTrack.FrameType = reflect.TypeOf(to).Elem()
+	}
+	return ret
+}
+
+func (c *AVFrameConvert[T]) ConvertFromAVFrame(avFrame *AVFrame) (to T, err error) {
+	to = reflect.New(c.ToTrack.FrameType).Interface().(T)
+	if c.ToTrack.ICodecCtx == nil {
+		if c.ToTrack.ICodecCtx, c.ToTrack.SequenceFrame, err = to.ConvertCtx(c.FromTrack.ICodecCtx); err != nil {
+			return
+		}
+	}
+	if err = avFrame.Demux(c.FromTrack.ICodecCtx); err != nil {
+		return
+	}
+	to.SetAllocator(avFrame.Wraps[0].GetAllocator())
+	to.Mux(c.ToTrack.ICodecCtx, avFrame)
+	return
+}
+
+func (c *AVFrameConvert[T]) Convert(frame IAVFrame) (to T, err error) {
+	to = reflect.New(c.ToTrack.FrameType).Interface().(T)
+	// Not From Publisher
+	if c.FromTrack.LastValue == nil {
+		err = frame.Parse(c.FromTrack)
+		if err != nil {
+			return
+		}
+	}
+	if c.ToTrack.ICodecCtx == nil || c.lastFromCodecCtx != c.FromTrack.ICodecCtx {
+		if c.ToTrack.ICodecCtx, c.ToTrack.SequenceFrame, err = to.ConvertCtx(c.FromTrack.ICodecCtx); err != nil {
+			return
+		}
+	}
+	c.lastFromCodecCtx = c.FromTrack.ICodecCtx
+	if c.FromTrack.Value.Raw, err = frame.Demux(c.FromTrack.ICodecCtx); err != nil {
+		return
+	}
+	to.SetAllocator(frame.GetAllocator())
+	to.Mux(c.ToTrack.ICodecCtx, &c.FromTrack.Value)
+	return
+}

pkg/config/types.go

@@ -16,6 +16,9 @@ const (
 	RelayModeRelay = "relay"
 	RelayModeMix   = "mix"
 
+	RecordModeAuto  RecordMode = "auto"
+	RecordModeEvent RecordMode = "event"
+
 	HookOnServerKeepAlive HookType = "server_keep_alive"
 	HookOnPublishStart    HookType = "publish_start"
 	HookOnPublishEnd      HookType = "publish_end"
@@ -29,11 +32,16 @@ const (
 	HookOnRecordEnd       HookType = "record_end"
 	HookOnTransformStart  HookType = "transform_start"
 	HookOnTransformEnd    HookType = "transform_end"
+
+	EventLevelLow  EventLevel = "low"
+	EventLevelHigh EventLevel = "high"
 )
 
 type (
-	HookType string
-	Publish  struct {
+	EventLevel = string
+	RecordMode = string
+	HookType   string
+	Publish    struct {
 		MaxCount          int             `default:"0" desc:"最大发布者数量"` // 最大发布者数量
 		PubAudio          bool            `default:"true" desc:"是否发布音频"`
 		PubVideo          bool            `default:"true" desc:"是否发布视频"`
@@ -62,9 +70,10 @@ type (
 		SyncMode        int           `default:"1" desc:"同步模式" enum:"0:采用时间戳同步,1:采用写入时间同步"` // 0，采用时间戳同步，1，采用写入时间同步
 		IFrameOnly      bool          `desc:"只要关键帧"`                                        // 只要关键帧
 		WaitTimeout     time.Duration `default:"10s" desc:"等待流超时时间"`                        // 等待流超时
-		WriteBufferSize int           `desc:"写缓冲大小"`                                        // 写缓冲大小
-		Key             string        `desc:"订阅鉴权key"`                                      // 订阅鉴权key
-		SubType         string        `desc:"订阅类型"`                                         // 订阅类型
+		WaitTrack       string        `default:"video" desc:"等待轨道" enum:"audio:等待音频,video:等待视频,all:等待全部"`
+		WriteBufferSize int           `desc:"写缓冲大小"`   // 写缓冲大小
+		Key             string        `desc:"订阅鉴权key"` // 订阅鉴权key
+		SubType         string        `desc:"订阅类型"`    // 订阅类型
 	}
 	HTTPValues map[string][]string
 	Pull       struct {
@@ -84,11 +93,21 @@ type (
 		Proxy         string        `desc:"代理地址"`                    // 代理地址
 		Header        HTTPValues
 	}
+	RecordEvent struct {
+		EventId        string
+		BeforeDuration uint32     `json:"beforeDuration" desc:"事件前缓存时长" gorm:"comment:事件前缓存时长;default:30000"`
+		AfterDuration  uint32     `json:"afterDuration" desc:"事件后缓存时长" gorm:"comment:事件后缓存时长;default:30000"`
+		EventDesc      string     `json:"eventDesc" desc:"事件描述" gorm:"type:varchar(255);comment:事件描述"`
+		EventLevel     EventLevel `json:"eventLevel" desc:"事件级别" gorm:"type:varchar(255);comment:事件级别,high表示重要事件，无法删除且表示无需自动删除,low表示非重要事件,达到自动删除时间后，自动删除;default:'low'"`
+		EventName      string     `json:"eventName" desc:"事件名称" gorm:"type:varchar(255);comment:事件名称"`
+	}
 	Record struct {
-		Type     string        `desc:"录制类型"`   // 录制类型 mp4、flv、hls、hlsv7
-		FilePath string        `desc:"录制文件路径"` // 录制文件路径
-		Fragment time.Duration `desc:"分片时长"`   // 分片时长
-		Append   bool          `desc:"是否追加录制"` // 是否追加录制
+		Mode     RecordMode    `json:"mode" desc:"事件类型,auto=连续录像模式，event=事件录像模式" gorm:"type:varchar(255);comment:事件类型,auto=连续录像模式，event=事件录像模式;default:'auto'"`
+		Type     string        `desc:"录制类型"`                         // 录制类型 mp4、flv、hls、hlsv7
+		FilePath string        `desc:"录制文件路径"`                       // 录制文件路径
+		Fragment time.Duration `desc:"分片时长"`                         // 分片时长
+		Append   bool          `desc:"是否追加录制"`                       // 是否追加录制
+		Event    *RecordEvent  `json:"event" desc:"事件录像配置" gorm:"-"` // 事件录像配置
 	}
 	TransfromOutput struct {
 		Target     string `desc:"转码目标"` // 转码目标

pkg/db/user.go

@@ -9,14 +9,11 @@ import (
 
 // User represents a user in the system
 type User struct {
-	ID        uint `gorm:"primarykey"`
-	CreatedAt time.Time
-	UpdatedAt time.Time
-	DeletedAt gorm.DeletedAt `gorm:"index"`
-	Username  string         `gorm:"uniqueIndex;size:64"`
-	Password  string         `gorm:"size:60"`                // bcrypt hash
-	Role      string         `gorm:"size:20;default:'user'"` // admin or user
-	LastLogin time.Time      `gorm:"type:datetime;default:CURRENT_TIMESTAMP"`
+	gorm.Model
+	Username  string    `gorm:"uniqueIndex;size:64"`
+	Password  string    `gorm:"size:60"`                // bcrypt hash
+	Role      string    `gorm:"size:20;default:'user'"` // admin or user
+	LastLogin time.Time `gorm:"type:timestamp;default:CURRENT_TIMESTAMP"`
 }
 
 // BeforeCreate hook to hash password before saving

pkg/util/buddy.go

@@ -2,33 +2,55 @@ package util
 
 import (
 	"errors"
+	"sync"
+	"unsafe"
 )
 
 type Buddy struct {
-	size     int
-	longests []int
+	size       int
+	longests   [BuddySize>>(MinPowerOf2-1) - 1]int
+	memoryPool [BuddySize]byte
+	poolStart  int64
+	lock       sync.Mutex // 保护 longests 数组的并发访问
 }
 
 var (
 	InValidParameterErr = errors.New("buddy: invalid parameter")
 	NotFoundErr         = errors.New("buddy: can't find block")
+	buddyPool           = sync.Pool{
+		New: func() interface{} {
+			return NewBuddy()
+		},
+	}
 )
 
+// GetBuddy 从池中获取一个 Buddy 实例
+func GetBuddy() *Buddy {
+	buddy := buddyPool.Get().(*Buddy)
+	return buddy
+}
+
+// PutBuddy 将 Buddy 实例放回池中
+func PutBuddy(b *Buddy) {
+	buddyPool.Put(b)
+}
+
 // NewBuddy creates a buddy instance.
 // If the parameter isn't valid, return the nil and error as well
-func NewBuddy(size int) *Buddy {
-	if !isPowerOf2(size) {
-		size = fixSize(size)
+func NewBuddy() *Buddy {
+	size := BuddySize >> MinPowerOf2
+	ret := &Buddy{
+		size: size,
 	}
-	nodeCount := 2*size - 1
-	longests := make([]int, nodeCount)
-	for nodeSize, i := 2*size, 0; i < nodeCount; i++ {
+	for nodeSize, i := 2*size, 0; i < len(ret.longests); i++ {
 		if isPowerOf2(i + 1) {
 			nodeSize /= 2
 		}
-		longests[i] = nodeSize
+		ret.longests[i] = nodeSize
 	}
-	return &Buddy{size, longests}
+	ret.poolStart = int64(uintptr(unsafe.Pointer(&ret.memoryPool[0])))
+
+	return ret
 }
 
 // Alloc find a unused block according to the size
@@ -42,6 +64,8 @@ func (b *Buddy) Alloc(size int) (offset int, err error) {
 	if !isPowerOf2(size) {
 		size = fixSize(size)
 	}
+	b.lock.Lock()
+	defer b.lock.Unlock()
 	if size > b.longests[0] {
 		err = NotFoundErr
 		return
@@ -70,6 +94,8 @@ func (b *Buddy) Free(offset int) error {
 	if offset < 0 || offset >= b.size {
 		return InValidParameterErr
 	}
+	b.lock.Lock()
+	defer b.lock.Unlock()
 	nodeSize := 1
 	index := offset + b.size - 1
 	for ; b.longests[index] != 0; index = parent(index) {

pkg/util/rm_enable.go

@@ -3,11 +3,9 @@
 package util
 
 import (
-	"container/list"
 	"fmt"
 	"io"
 	"slices"
-	"sync"
 	"unsafe"
 )
 
@@ -58,53 +56,59 @@ func (r *RecyclableMemory) Recycle() {
 	}
 }
 
-var (
-	memoryPool [BuddySize]byte
-	buddy      = NewBuddy(BuddySize >> MinPowerOf2)
-	lock       sync.Mutex
-	poolStart  = int64(uintptr(unsafe.Pointer(&memoryPool[0])))
-	blockPool  = list.New()
-	//EnableCheckSize bool = false
-)
-
 type MemoryAllocator struct {
 	allocator *Allocator
 	start     int64
 	memory    []byte
 	Size      int
+	buddy     *Buddy
+}
+
+// createMemoryAllocator 创建并初始化 MemoryAllocator
+func createMemoryAllocator(size int, buddy *Buddy, offset int) *MemoryAllocator {
+	ret := &MemoryAllocator{
+		allocator: NewAllocator(size),
+		buddy:     buddy,
+		Size:      size,
+		memory:    buddy.memoryPool[offset : offset+size],
+		start:     buddy.poolStart + int64(offset),
+	}
+	ret.allocator.Init(size)
+	return ret
 }
 
 func GetMemoryAllocator(size int) (ret *MemoryAllocator) {
-	lock.Lock()
-	offset, err := buddy.Alloc(size >> MinPowerOf2)
-	if blockPool.Len() > 0 {
-		ret = blockPool.Remove(blockPool.Front()).(*MemoryAllocator)
-	} else {
-		ret = &MemoryAllocator{
-			allocator: NewAllocator(size),
+	if size < BuddySize {
+		requiredSize := size >> MinPowerOf2
+		// 循环尝试从池中获取可用的 buddy
+		for {
+			buddy := GetBuddy()
+			offset, err := buddy.Alloc(requiredSize)
+			PutBuddy(buddy)
+			if err == nil {
+				// 分配成功，使用这个 buddy
+				return createMemoryAllocator(size, buddy, offset<<MinPowerOf2)
+			}
 		}
 	}
-	lock.Unlock()
-	ret.Size = size
-	ret.allocator.Init(size)
-	if err != nil {
-		ret.memory = make([]byte, size)
-		ret.start = int64(uintptr(unsafe.Pointer(&ret.memory[0])))
-		return
+	// 池中的 buddy 都无法分配或大小不够，使用系统内存
+	memory := make([]byte, size)
+	start := int64(uintptr(unsafe.Pointer(&memory[0])))
+	return &MemoryAllocator{
+		allocator: NewAllocator(size),
+		Size:      size,
+		memory:    memory,
+		start:     start,
 	}
-	offset = offset << MinPowerOf2
-	ret.memory = memoryPool[offset : offset+size]
-	ret.start = poolStart + int64(offset)
-	return
 }
 
 func (ma *MemoryAllocator) Recycle() {
 	ma.allocator.Recycle()
-	lock.Lock()
-	blockPool.PushBack(ma)
-	_ = buddy.Free(int((poolStart - ma.start) >> MinPowerOf2))
+	if ma.buddy != nil {
+		_ = ma.buddy.Free(int((ma.buddy.poolStart - ma.start) >> MinPowerOf2))
+		ma.buddy = nil
+	}
 	ma.memory = nil
-	lock.Unlock()
 }
 
 func (ma *MemoryAllocator) Find(size int) (memory []byte) {

plugin.go

@@ -133,24 +133,9 @@ func (plugin *PluginMeta) Init(s *Server, userConfig map[string]any) (p *Plugin)
 	finalConfig, _ := yaml.Marshal(p.Config.GetMap())
 	p.Logger.Handler().(*MultiLogHandler).SetLevel(ParseLevel(p.config.LogLevel))
 	p.Debug("config", "detail", string(finalConfig))
-	if s.DisableAll {
-		p.Disabled = true
-	}
-	if userConfig["enable"] == false {
-		p.Disabled = true
-	} else if userConfig["enable"] == true {
-		p.Disabled = false
-	}
-	if p.Disabled {
+	if userConfig["enable"] == false || (s.DisableAll && userConfig["enable"] != true) {
 		p.disable("config")
-		p.Warn("plugin disabled")
 		return
-	} else {
-		var handlers map[string]http.HandlerFunc
-		if v, ok := instance.(IRegisterHandler); ok {
-			handlers = v.RegisterHandler()
-		}
-		p.registerHandler(handlers)
 	}
 	p.Info("init", "version", plugin.Version)
 	var err error
@@ -158,7 +143,7 @@ func (plugin *PluginMeta) Init(s *Server, userConfig map[string]any) (p *Plugin)
 		p.DB = s.DB
 	} else if p.config.DSN != "" {
 		if factory, ok := db.Factory[p.config.DBType]; ok {
-			s.DB, err = gorm.Open(factory(p.config.DSN), &gorm.Config{})
+			p.DB, err = gorm.Open(factory(p.config.DSN), &gorm.Config{})
 			if err != nil {
 				s.Error("failed to connect database", "error", err, "dsn", s.config.DSN, "type", s.config.DBType)
 				p.disable(fmt.Sprintf("database %v", err))
@@ -171,8 +156,21 @@ func (plugin *PluginMeta) Init(s *Server, userConfig map[string]any) (p *Plugin)
 			p.disable(fmt.Sprintf("auto migrate record stream failed %v", err))
 			return
 		}
+		if err = p.DB.AutoMigrate(&EventRecordStream{}); err != nil {
+			p.disable(fmt.Sprintf("auto migrate event record stream failed %v", err))
+			return
+		}
 	}
-	s.AddTask(instance)
+	if err := s.AddTask(instance).WaitStarted(); err != nil {
+		p.disable(instance.StopReason().Error())
+		return
+	}
+	var handlers map[string]http.HandlerFunc
+	if v, ok := instance.(IRegisterHandler); ok {
+		handlers = v.RegisterHandler()
+	}
+	p.registerHandler(handlers)
+	s.Plugins.Add(p)
 	return
 }
 
@@ -277,11 +275,19 @@ func (p *Plugin) GetPublicIP(netcardIP string) string {
 func (p *Plugin) disable(reason string) {
 	p.Disabled = true
 	p.SetDescription("disableReason", reason)
+	p.Warn("plugin disabled")
 	p.Server.disabledPlugins = append(p.Server.disabledPlugins, p)
 }
 
 func (p *Plugin) Start() (err error) {
 	s := p.Server
+
+	if err = p.listen(); err != nil {
+		return
+	}
+	if err = p.handler.OnInit(); err != nil {
+		return
+	}
 	if p.Meta.ServiceDesc != nil && s.grpcServer != nil {
 		s.grpcServer.RegisterService(p.Meta.ServiceDesc, p.handler)
 		if p.Meta.RegisterGRPCHandler != nil {
@@ -293,15 +299,6 @@ func (p *Plugin) Start() (err error) {
 			}
 		}
 	}
-	s.Plugins.Add(p)
-	if err = p.listen(); err != nil {
-		p.disable(fmt.Sprintf("listen %v", err))
-		return
-	}
-	if err = p.handler.OnInit(); err != nil {
-		p.disable(fmt.Sprintf("init %v", err))
-		return
-	}
 	if p.config.Hook != nil {
 		if hook, ok := p.config.Hook[config.HookOnServerKeepAlive]; ok && hook.Interval > 0 {
 			p.AddTask(&ServerKeepAliveTask{plugin: p})
@@ -616,7 +613,9 @@ func (p *Plugin) SubscribeWithConfig(ctx context.Context, streamPath string, con
 	if err == nil {
 		select {
 		case <-subscriber.waitPublishDone:
-			err = subscriber.Publisher.WaitTrack()
+			waitAudio := conf.WaitTrack == "all" || strings.Contains(conf.WaitTrack, "audio")
+			waitVideo := conf.WaitTrack == "all" || strings.Contains(conf.WaitTrack, "video")
+			err = subscriber.Publisher.WaitTrack(waitAudio, waitVideo)
 		case <-subscriber.Done():
 			err = subscriber.StopReason()
 		}
@@ -719,10 +718,11 @@ func (p *Plugin) registerHandler(handlers map[string]http.HandlerFunc) {
 			streamPath := r.PathValue("streamPath")
 			t := r.PathValue("type")
 			expire := r.URL.Query().Get("expire")
-			if t == "publish" {
+			switch t {
+			case "publish":
 				secret := md5.Sum([]byte(p.config.Publish.Key + streamPath + expire))
 				rw.Write([]byte(hex.EncodeToString(secret[:])))
-			} else if t == "subscribe" {
+			case "subscribe":
 				secret := md5.Sum([]byte(p.config.Subscribe.Key + streamPath + expire))
 				rw.Write([]byte(hex.EncodeToString(secret[:])))
 			}

plugin/crontab/api.go

@@ -2,7 +2,10 @@ package plugin_crontab
 
 import (
 	"context"
+	"fmt"
+	"sort"
 	"strings"
+	"time"
 
 	"google.golang.org/protobuf/types/known/timestamppb"
 	cronpb "m7s.live/v5/plugin/crontab/pb"
@@ -17,34 +20,29 @@ func (ct *CrontabPlugin) List(ctx context.Context, req *cronpb.ReqPlanList) (*cr
 		req.PageSize = 10
 	}
 
-	var total int64
-	var plans []pkg.RecordPlan
+	// 从内存中获取所有计划
+	plans := ct.recordPlans.Items
+	total := len(plans)
 
-	query := ct.DB.Model(&pkg.RecordPlan{})
-
-	result := query.Count(&total)
-	if result.Error != nil {
-		return &cronpb.PlanResponseList{
-			Code:    500,
-			Message: result.Error.Error(),
-		}, nil
+	// 计算分页
+	start := int(req.PageNum-1) * int(req.PageSize)
+	end := start + int(req.PageSize)
+	if start >= total {
+		start = total
+	}
+	if end > total {
+		end = total
 	}
 
-	offset := (req.PageNum - 1) * req.PageSize
-	result = query.Order("id desc").Offset(int(offset)).Limit(int(req.PageSize)).Find(&plans)
-	if result.Error != nil {
-		return &cronpb.PlanResponseList{
-			Code:    500,
-			Message: result.Error.Error(),
-		}, nil
-	}
+	// 获取当前页的数据
+	pagePlans := plans[start:end]
 
-	data := make([]*cronpb.Plan, 0, len(plans))
-	for _, plan := range plans {
+	data := make([]*cronpb.Plan, 0, len(pagePlans))
+	for _, plan := range pagePlans {
 		data = append(data, &cronpb.Plan{
 			Id:         uint32(plan.ID),
 			Name:       plan.Name,
-			Enable:     plan.Enabled,
+			Enable:     plan.Enable,
 			CreateTime: timestamppb.New(plan.CreatedAt),
 			UpdateTime: timestamppb.New(plan.UpdatedAt),
 			Plan:       plan.Plan,
@@ -94,9 +92,9 @@ func (ct *CrontabPlugin) Add(ctx context.Context, req *cronpb.Plan) (*cronpb.Res
 	}
 
 	plan := &pkg.RecordPlan{
-		Name:    req.Name,
-		Plan:    req.Plan,
-		Enabled: req.Enable,
+		Name:   req.Name,
+		Plan:   req.Plan,
+		Enable: req.Enable,
 	}
 
 	if err := ct.DB.Create(plan).Error; err != nil {
@@ -106,6 +104,9 @@ func (ct *CrontabPlugin) Add(ctx context.Context, req *cronpb.Plan) (*cronpb.Res
 		}, nil
 	}
 
+	// 添加到内存中
+	ct.recordPlans.Add(plan)
+
 	return &cronpb.Response{
 		Code:    0,
 		Message: "success",
@@ -160,10 +161,14 @@ func (ct *CrontabPlugin) Update(ctx context.Context, req *cronpb.Plan) (*cronpb.
 		}, nil
 	}
 
+	// 处理 enable 状态变更
+	enableChanged := existingPlan.Enable != req.Enable
+
+	// 更新记录
 	updates := map[string]interface{}{
-		"name":    req.Name,
-		"plan":    req.Plan,
-		"enabled": req.Enable,
+		"name":   req.Name,
+		"plan":   req.Plan,
+		"enable": req.Enable,
 	}
 
 	if err := ct.DB.Model(&existingPlan).Updates(updates).Error; err != nil {
@@ -173,6 +178,45 @@ func (ct *CrontabPlugin) Update(ctx context.Context, req *cronpb.Plan) (*cronpb.
 		}, nil
 	}
 
+	// 更新内存中的记录
+	existingPlan.Name = req.Name
+	existingPlan.Plan = req.Plan
+	existingPlan.Enable = req.Enable
+	ct.recordPlans.Set(&existingPlan)
+
+	// 处理 enable 状态变更后的操作
+	if enableChanged {
+		if req.Enable {
+			// 从 false 变为 true，需要创建并启动新的定时任务
+			var streams []pkg.RecordPlanStream
+			model := &pkg.RecordPlanStream{PlanID: existingPlan.ID}
+			if err := ct.DB.Model(model).Where(model).Find(&streams).Error; err != nil {
+				ct.Error("query record plan streams error: %v", err)
+			} else {
+				// 为每个流创建定时任务
+				for _, stream := range streams {
+					crontab := &Crontab{
+						ctp:              ct,
+						RecordPlan:       &existingPlan,
+						RecordPlanStream: &stream,
+					}
+					crontab.OnStart(func() {
+						ct.crontabs.Set(crontab)
+					})
+					ct.AddTask(crontab)
+				}
+			}
+		} else {
+			// 从 true 变为 false，需要停止相关的定时任务
+			ct.crontabs.Range(func(crontab *Crontab) bool {
+				if crontab.RecordPlan.ID == existingPlan.ID {
+					crontab.Stop(nil)
+				}
+				return true
+			})
+		}
+	}
+
 	return &cronpb.Response{
 		Code:    0,
 		Message: "success",
@@ -196,6 +240,14 @@ func (ct *CrontabPlugin) Remove(ctx context.Context, req *cronpb.DeleteRequest)
 		}, nil
 	}
 
+	// 先停止所有相关的定时任务
+	ct.crontabs.Range(func(crontab *Crontab) bool {
+		if crontab.RecordPlan.ID == existingPlan.ID {
+			crontab.Stop(nil)
+		}
+		return true
+	})
+
 	// 执行软删除
 	if err := ct.DB.Delete(&existingPlan).Error; err != nil {
 		return &cronpb.Response{
@@ -204,8 +256,735 @@ func (ct *CrontabPlugin) Remove(ctx context.Context, req *cronpb.DeleteRequest)
 		}, nil
 	}
 
+	// 从内存中移除
+	ct.recordPlans.RemoveByKey(existingPlan.ID)
+
+	return &cronpb.Response{
+		Code:    0,
+		Message: "success",
+	}, nil
+}
+
+func (ct *CrontabPlugin) ListRecordPlanStreams(ctx context.Context, req *cronpb.ReqPlanStreamList) (*cronpb.RecordPlanStreamResponseList, error) {
+	if req.PageNum < 1 {
+		req.PageNum = 1
+	}
+	if req.PageSize < 1 {
+		req.PageSize = 10
+	}
+
+	var total int64
+	var streams []pkg.RecordPlanStream
+	model := &pkg.RecordPlanStream{}
+
+	// 构建查询条件
+	query := ct.DB.Model(model).
+		Scopes(
+			pkg.ScopeRecordPlanID(uint(req.PlanId)),
+			pkg.ScopeStreamPathLike(req.StreamPath),
+			pkg.ScopeOrderByCreatedAtDesc(),
+		)
+
+	result := query.Count(&total)
+	if result.Error != nil {
+		return &cronpb.RecordPlanStreamResponseList{
+			Code:    500,
+			Message: result.Error.Error(),
+		}, nil
+	}
+
+	offset := (req.PageNum - 1) * req.PageSize
+	result = query.Offset(int(offset)).Limit(int(req.PageSize)).Find(&streams)
+
+	if result.Error != nil {
+		return &cronpb.RecordPlanStreamResponseList{
+			Code:    500,
+			Message: result.Error.Error(),
+		}, nil
+	}
+
+	data := make([]*cronpb.PlanStream, 0, len(streams))
+	for _, stream := range streams {
+		data = append(data, &cronpb.PlanStream{
+			PlanId:     uint32(stream.PlanID),
+			StreamPath: stream.StreamPath,
+			Fragment:   stream.Fragment,
+			FilePath:   stream.FilePath,
+			CreatedAt:  timestamppb.New(stream.CreatedAt),
+			UpdatedAt:  timestamppb.New(stream.UpdatedAt),
+			Enable:     stream.Enable,
+		})
+	}
+
+	return &cronpb.RecordPlanStreamResponseList{
+		Code:       0,
+		Message:    "success",
+		TotalCount: uint32(total),
+		PageNum:    req.PageNum,
+		PageSize:   req.PageSize,
+		Data:       data,
+	}, nil
+}
+
+func (ct *CrontabPlugin) AddRecordPlanStream(ctx context.Context, req *cronpb.PlanStream) (*cronpb.Response, error) {
+	if req.PlanId == 0 {
+		return &cronpb.Response{
+			Code:    400,
+			Message: "record_plan_id is required",
+		}, nil
+	}
+
+	if strings.TrimSpace(req.StreamPath) == "" {
+		return &cronpb.Response{
+			Code:    400,
+			Message: "stream_path is required",
+		}, nil
+	}
+
+	// 从内存中获取录制计划
+	plan, ok := ct.recordPlans.Get(uint(req.PlanId))
+	if !ok {
+		return &cronpb.Response{
+			Code:    404,
+			Message: "record plan not found",
+		}, nil
+	}
+
+	// 检查是否已存在相同的记录
+	var count int64
+	searchModel := pkg.RecordPlanStream{
+		PlanID:     uint(req.PlanId),
+		StreamPath: req.StreamPath,
+	}
+	if err := ct.DB.Model(&searchModel).Where(&searchModel).Count(&count).Error; err != nil {
+		return &cronpb.Response{
+			Code:    500,
+			Message: err.Error(),
+		}, nil
+	}
+
+	if count > 0 {
+		return &cronpb.Response{
+			Code:    400,
+			Message: "record already exists",
+		}, nil
+	}
+
+	stream := &pkg.RecordPlanStream{
+		PlanID:     uint(req.PlanId),
+		StreamPath: req.StreamPath,
+		Fragment:   req.Fragment,
+		FilePath:   req.FilePath,
+		Enable:     req.Enable,
+		RecordType: req.RecordType,
+	}
+
+	if err := ct.DB.Create(stream).Error; err != nil {
+		return &cronpb.Response{
+			Code:    500,
+			Message: err.Error(),
+		}, nil
+	}
+
+	// 如果计划是启用状态，创建并启动定时任务
+	if plan.Enable {
+		crontab := &Crontab{
+			ctp:              ct,
+			RecordPlan:       plan,
+			RecordPlanStream: stream,
+		}
+		crontab.OnStart(func() {
+			ct.crontabs.Set(crontab)
+		})
+		ct.AddTask(crontab)
+	}
+
+	return &cronpb.Response{
+		Code:    0,
+		Message: "success",
+	}, nil
+}
+
+func (ct *CrontabPlugin) UpdateRecordPlanStream(ctx context.Context, req *cronpb.PlanStream) (*cronpb.Response, error) {
+	if req.PlanId == 0 {
+		return &cronpb.Response{
+			Code:    400,
+			Message: "record_plan_id is required",
+		}, nil
+	}
+
+	if strings.TrimSpace(req.StreamPath) == "" {
+		return &cronpb.Response{
+			Code:    400,
+			Message: "stream_path is required",
+		}, nil
+	}
+
+	// 检查记录是否存在
+	var existingStream pkg.RecordPlanStream
+	searchModel := pkg.RecordPlanStream{
+		PlanID:     uint(req.PlanId),
+		StreamPath: req.StreamPath,
+	}
+	if err := ct.DB.Where(&searchModel).First(&existingStream).Error; err != nil {
+		return &cronpb.Response{
+			Code:    404,
+			Message: "record not found",
+		}, nil
+	}
+
+	// 更新记录
+	existingStream.Fragment = req.Fragment
+	existingStream.FilePath = req.FilePath
+	existingStream.Enable = req.Enable
+	existingStream.RecordType = req.RecordType
+
+	if err := ct.DB.Save(&existingStream).Error; err != nil {
+		return &cronpb.Response{
+			Code:    500,
+			Message: err.Error(),
+		}, nil
+	}
+
+	// 停止当前流相关的所有任务
+	ct.crontabs.Range(func(crontab *Crontab) bool {
+		if crontab.RecordPlanStream.StreamPath == req.StreamPath {
+			crontab.Stop(nil)
+		}
+		return true
+	})
+
+	// 查询所有关联此流的记录
+	var streams []pkg.RecordPlanStream
+	if err := ct.DB.Where("stream_path = ?", req.StreamPath).Find(&streams).Error; err != nil {
+		ct.Error("query record plan streams error: %v", err)
+		return &cronpb.Response{
+			Code:    500,
+			Message: err.Error(),
+		}, nil
+	}
+
+	// 为每个启用的计划创建新的定时任务
+	for _, stream := range streams {
+		// 从内存中获取对应的计划
+		plan, ok := ct.recordPlans.Get(stream.PlanID)
+		if !ok {
+			ct.Error("record plan not found in memory: %d", stream.PlanID)
+			continue
+		}
+
+		// 如果计划是启用状态，创建并启动定时任务
+		if plan.Enable && stream.Enable {
+			crontab := &Crontab{
+				ctp:              ct,
+				RecordPlan:       plan,
+				RecordPlanStream: &stream,
+			}
+			crontab.OnStart(func() {
+				ct.crontabs.Set(crontab)
+			})
+			ct.AddTask(crontab)
+		}
+	}
+
+	return &cronpb.Response{
+		Code:    0,
+		Message: "success",
+	}, nil
+}
+
+func (ct *CrontabPlugin) RemoveRecordPlanStream(ctx context.Context, req *cronpb.DeletePlanStreamRequest) (*cronpb.Response, error) {
+	if req.PlanId == 0 {
+		return &cronpb.Response{
+			Code:    400,
+			Message: "record_plan_id is required",
+		}, nil
+	}
+
+	if strings.TrimSpace(req.StreamPath) == "" {
+		return &cronpb.Response{
+			Code:    400,
+			Message: "stream_path is required",
+		}, nil
+	}
+
+	// 检查记录是否存在
+	var existingStream pkg.RecordPlanStream
+	searchModel := pkg.RecordPlanStream{
+		PlanID:     uint(req.PlanId),
+		StreamPath: req.StreamPath,
+	}
+	if err := ct.DB.Where(&searchModel).First(&existingStream).Error; err != nil {
+		return &cronpb.Response{
+			Code:    404,
+			Message: "record not found",
+		}, nil
+	}
+
+	// 停止所有相关的定时任务
+	ct.crontabs.Range(func(crontab *Crontab) bool {
+		if crontab.RecordPlanStream.StreamPath == req.StreamPath && crontab.RecordPlan.ID == uint(req.PlanId) {
+			crontab.Stop(nil)
+		}
+		return true
+	})
+
+	// 执行删除
+	if err := ct.DB.Delete(&existingStream).Error; err != nil {
+		return &cronpb.Response{
+			Code:    500,
+			Message: err.Error(),
+		}, nil
+	}
+
 	return &cronpb.Response{
 		Code:    0,
 		Message: "success",
 	}, nil
 }
+
+// 获取周几的名称（0=周日，1=周一，...，6=周六）
+func getWeekdayName(weekday int) string {
+	weekdays := []string{"周日", "周一", "周二", "周三", "周四", "周五", "周六"}
+	return weekdays[weekday]
+}
+
+// 获取周几的索引（0=周日，1=周一，...，6=周六）
+func getWeekdayIndex(weekdayName string) int {
+	weekdays := map[string]int{
+		"周日": 0, "周一": 1, "周二": 2, "周三": 3, "周四": 4, "周五": 5, "周六": 6,
+	}
+	return weekdays[weekdayName]
+}
+
+// 获取下一个指定周几的日期
+func getNextDateForWeekday(now time.Time, targetWeekday int, location *time.Location) time.Time {
+	nowWeekday := int(now.Weekday())
+	daysToAdd := 0
+
+	if targetWeekday >= nowWeekday {
+		daysToAdd = targetWeekday - nowWeekday
+	} else {
+		daysToAdd = 7 - (nowWeekday - targetWeekday)
+	}
+
+	// 如果是同一天但当前时间已经过了最后的时间段，则推到下一周
+	if daysToAdd == 0 {
+		// 这里简化处理，直接加7天到下周同一天
+		daysToAdd = 7
+	}
+
+	return now.AddDate(0, 0, daysToAdd)
+}
+
+// 计算计划中的所有时间段
+func calculateTimeSlots(plan string, now time.Time, location *time.Location) ([]*cronpb.TimeSlotInfo, error) {
+	if len(plan) != 168 {
+		return nil, fmt.Errorf("invalid plan format: length should be 168")
+	}
+
+	var slots []*cronpb.TimeSlotInfo
+
+	// 按周几遍历（0=周日，1=周一，...，6=周六）
+	for weekday := 0; weekday < 7; weekday++ {
+		dayOffset := weekday * 24
+		var startHour int = -1
+
+		// 遍历这一天的每个小时
+		for hour := 0; hour <= 24; hour++ {
+			// 如果到了一天的结尾或者当前小时状态为0
+			isEndOfDay := hour == 24
+			isHourOff := !isEndOfDay && plan[dayOffset+hour] == '0'
+
+			if isEndOfDay || isHourOff {
+				// 如果之前有开始的时间段，现在结束了
+				if startHour != -1 {
+					// 计算下一个该周几的日期
+					targetDate := getNextDateForWeekday(now, weekday, location)
+
+					// 创建时间段
+					startTime := time.Date(targetDate.Year(), targetDate.Month(), targetDate.Day(), startHour, 0, 0, 0, location)
+					endTime := time.Date(targetDate.Year(), targetDate.Month(), targetDate.Day(), hour, 0, 0, 0, location)
+
+					// 转换为 UTC 时间
+					startTs := timestamppb.New(startTime.UTC())
+					endTs := timestamppb.New(endTime.UTC())
+
+					slots = append(slots, &cronpb.TimeSlotInfo{
+						Start:     startTs,
+						End:       endTs,
+						Weekday:   getWeekdayName(weekday),
+						TimeRange: fmt.Sprintf("%02d:00-%02d:00", startHour, hour),
+					})
+					startHour = -1
+				}
+			} else if plan[dayOffset+hour] == '1' && startHour == -1 {
+				// 找到新的开始时间
+				startHour = hour
+			}
+		}
+	}
+
+	// 按时间排序
+	sort.Slice(slots, func(i, j int) bool {
+		// 先按周几排序
+		weekdayI := getWeekdayIndex(slots[i].Weekday)
+		weekdayJ := getWeekdayIndex(slots[j].Weekday)
+
+		if weekdayI != weekdayJ {
+			return weekdayI < weekdayJ
+		}
+
+		// 同一天按开始时间排序
+		return slots[i].Start.AsTime().Hour() < slots[j].Start.AsTime().Hour()
+	})
+
+	return slots, nil
+}
+
+// 获取下一个时间段
+func getNextTimeSlotFromNow(plan string, now time.Time, location *time.Location) (*cronpb.TimeSlotInfo, error) {
+	if len(plan) != 168 {
+		return nil, fmt.Errorf("invalid plan format: length should be 168")
+	}
+
+	// 将当前时间转换为本地时间
+	localNow := now.In(location)
+	currentWeekday := int(localNow.Weekday())
+	currentHour := localNow.Hour()
+
+	// 检查是否在整点边界附近(前后30秒)
+	isNearHourBoundary := localNow.Minute() == 59 && localNow.Second() >= 30 || localNow.Minute() == 0 && localNow.Second() <= 30
+
+	// 首先检查当前时间是否在某个时间段内
+	dayOffset := currentWeekday * 24
+	if currentHour < 24 && plan[dayOffset+currentHour] == '1' {
+		// 找到当前小时所在的完整时间段
+		startHour := currentHour
+		// 向前查找时间段的开始
+		for h := currentHour - 1; h >= 0; h-- {
+			if plan[dayOffset+h] == '1' {
+				startHour = h
+			} else {
+				break
+			}
+		}
+
+		// 向后查找时间段的结束
+		endHour := currentHour + 1
+		for h := endHour; h < 24; h++ {
+			if plan[dayOffset+h] == '1' {
+				endHour = h + 1
+			} else {
+				break
+			}
+		}
+
+		// 检查是否已经接近当前时间段的结束
+		isNearEndOfTimeSlot := currentHour == endHour-1 && localNow.Minute() >= 59 && localNow.Second() >= 30
+
+		// 如果我们靠近时间段结束且在小时边界附近，我们跳过此时间段，找下一个
+		if isNearEndOfTimeSlot && isNearHourBoundary {
+			// 继续查找下一个时间段
+		} else {
+			// 创建时间段
+			startTime := time.Date(localNow.Year(), localNow.Month(), localNow.Day(), startHour, 0, 0, 0, location)
+			endTime := time.Date(localNow.Year(), localNow.Month(), localNow.Day(), endHour, 0, 0, 0, location)
+
+			// 如果当前时间已经接近或超过了结束时间，调整结束时间
+			if localNow.After(endTime.Add(-30*time.Second)) || localNow.Equal(endTime) {
+				// 继续查找下一个时间段
+			} else {
+				// 返回当前时间段
+				return &cronpb.TimeSlotInfo{
+					Start:     timestamppb.New(startTime.UTC()),
+					End:       timestamppb.New(endTime.UTC()),
+					Weekday:   getWeekdayName(currentWeekday),
+					TimeRange: fmt.Sprintf("%02d:00-%02d:00", startHour, endHour),
+				}, nil
+			}
+		}
+	}
+
+	// 查找下一个时间段
+	// 先查找当天剩余时间
+	for h := currentHour + 1; h < 24; h++ {
+		if plan[dayOffset+h] == '1' {
+			// 找到开始小时
+			startHour := h
+			// 查找结束小时
+			endHour := h + 1
+			for j := h + 1; j < 24; j++ {
+				if plan[dayOffset+j] == '1' {
+					endHour = j + 1
+				} else {
+					break
+				}
+			}
+
+			// 创建时间段
+			startTime := time.Date(localNow.Year(), localNow.Month(), localNow.Day(), startHour, 0, 0, 0, location)
+			endTime := time.Date(localNow.Year(), localNow.Month(), localNow.Day(), endHour, 0, 0, 0, location)
+
+			return &cronpb.TimeSlotInfo{
+				Start:     timestamppb.New(startTime.UTC()),
+				End:       timestamppb.New(endTime.UTC()),
+				Weekday:   getWeekdayName(currentWeekday),
+				TimeRange: fmt.Sprintf("%02d:00-%02d:00", startHour, endHour),
+			}, nil
+		}
+	}
+
+	// 如果当天没有找到，则查找后续日期
+	for d := 1; d <= 7; d++ {
+		nextDay := (currentWeekday + d) % 7
+		dayOffset := nextDay * 24
+
+		for h := 0; h < 24; h++ {
+			if plan[dayOffset+h] == '1' {
+				// 找到开始小时
+				startHour := h
+				// 查找结束小时
+				endHour := h + 1
+				for j := h + 1; j < 24; j++ {
+					if plan[dayOffset+j] == '1' {
+						endHour = j + 1
+					} else {
+						break
+					}
+				}
+
+				// 计算日期
+				nextDate := localNow.AddDate(0, 0, d)
+
+				// 创建时间段
+				startTime := time.Date(nextDate.Year(), nextDate.Month(), nextDate.Day(), startHour, 0, 0, 0, location)
+				endTime := time.Date(nextDate.Year(), nextDate.Month(), nextDate.Day(), endHour, 0, 0, 0, location)
+
+				return &cronpb.TimeSlotInfo{
+					Start:     timestamppb.New(startTime.UTC()),
+					End:       timestamppb.New(endTime.UTC()),
+					Weekday:   getWeekdayName(nextDay),
+					TimeRange: fmt.Sprintf("%02d:00-%02d:00", startHour, endHour),
+				}, nil
+			}
+		}
+	}
+
+	return nil, nil
+}
+
+func (ct *CrontabPlugin) ParsePlanTime(ctx context.Context, req *cronpb.ParsePlanRequest) (*cronpb.ParsePlanResponse, error) {
+	if len(req.Plan) != 168 {
+		return &cronpb.ParsePlanResponse{
+			Code:    400,
+			Message: "invalid plan format: length should be 168",
+		}, nil
+	}
+
+	// 检查字符串格式是否正确（只包含0和1）
+	for i, c := range req.Plan {
+		if c != '0' && c != '1' {
+			return &cronpb.ParsePlanResponse{
+				Code:    400,
+				Message: fmt.Sprintf("invalid character at position %d: %c (should be 0 or 1)", i, c),
+			}, nil
+		}
+	}
+
+	// 获取所有时间段
+	slots, err := calculateTimeSlots(req.Plan, time.Now(), time.Local)
+	if err != nil {
+		return &cronpb.ParsePlanResponse{
+			Code:    500,
+			Message: err.Error(),
+		}, nil
+	}
+
+	// 获取下一个时间段
+	nextSlot, err := getNextTimeSlotFromNow(req.Plan, time.Now(), time.Local)
+	if err != nil {
+		return &cronpb.ParsePlanResponse{
+			Code:    500,
+			Message: err.Error(),
+		}, nil
+	}
+
+	return &cronpb.ParsePlanResponse{
+		Code:     0,
+		Message:  "success",
+		Slots:    slots,
+		NextSlot: nextSlot,
+	}, nil
+}
+
+// 辅助函数：构建任务状态信息
+func buildCrontabTaskInfo(crontab *Crontab, now time.Time) *cronpb.CrontabTaskInfo {
+	// 基础任务信息
+	taskInfo := &cronpb.CrontabTaskInfo{
+		PlanId:     uint32(crontab.RecordPlan.ID),
+		PlanName:   crontab.RecordPlan.Name,
+		StreamPath: crontab.StreamPath,
+		FilePath:   crontab.FilePath,
+		Fragment:   crontab.Fragment,
+	}
+
+	// 获取完整计划时间段列表
+	if crontab.RecordPlan != nil && crontab.RecordPlan.Plan != "" {
+		planSlots, err := calculateTimeSlots(crontab.RecordPlan.Plan, now, time.Local)
+		if err == nil && planSlots != nil && len(planSlots) > 0 {
+			taskInfo.PlanSlots = planSlots
+		}
+	}
+
+	return taskInfo
+}
+
+// GetCrontabStatus 获取当前Crontab任务状态
+func (ct *CrontabPlugin) GetCrontabStatus(ctx context.Context, req *cronpb.CrontabStatusRequest) (*cronpb.CrontabStatusResponse, error) {
+	response := &cronpb.CrontabStatusResponse{
+		Code:         0,
+		Message:      "success",
+		RunningTasks: []*cronpb.CrontabTaskInfo{},
+		NextTasks:    []*cronpb.CrontabTaskInfo{},
+		TotalRunning: 0,
+		TotalPlanned: 0,
+	}
+
+	// 获取当前正在运行的任务
+	runningTasks := make([]*cronpb.CrontabTaskInfo, 0)
+	nextTasks := make([]*cronpb.CrontabTaskInfo, 0)
+
+	// 如果只指定了流路径但未找到对应的任务，也返回该流的计划信息
+	streamPathFound := false
+
+	// 遍历所有Crontab任务
+	ct.crontabs.Range(func(crontab *Crontab) bool {
+		// 如果指定了stream_path过滤条件，且不匹配，则跳过
+		if req.StreamPath != "" && crontab.StreamPath != req.StreamPath {
+			return true // 继续遍历
+		}
+
+		// 标记已找到指定的流
+		if req.StreamPath != "" {
+			streamPathFound = true
+		}
+
+		now := time.Now()
+
+		// 构建基本任务信息
+		taskInfo := buildCrontabTaskInfo(crontab, now)
+
+		// 检查是否正在录制
+		if crontab.recording && crontab.currentSlot != nil {
+			// 当前正在录制
+			taskInfo.IsRecording = true
+
+			// 设置时间信息
+			taskInfo.StartTime = timestamppb.New(crontab.currentSlot.Start)
+			taskInfo.EndTime = timestamppb.New(crontab.currentSlot.End)
+
+			// 计算已运行时间和剩余时间
+			elapsedDuration := now.Sub(crontab.currentSlot.Start)
+			remainingDuration := crontab.currentSlot.End.Sub(now)
+			taskInfo.ElapsedSeconds = uint32(elapsedDuration.Seconds())
+			taskInfo.RemainingSeconds = uint32(remainingDuration.Seconds())
+
+			// 设置时间范围和周几
+			startHour := crontab.currentSlot.Start.Hour()
+			endHour := crontab.currentSlot.End.Hour()
+			taskInfo.TimeRange = fmt.Sprintf("%02d:00-%02d:00", startHour, endHour)
+			taskInfo.Weekday = getWeekdayName(int(crontab.currentSlot.Start.Weekday()))
+
+			// 添加到正在运行的任务列表
+			runningTasks = append(runningTasks, taskInfo)
+		} else {
+			// 获取下一个时间段
+			nextSlot := crontab.getNextTimeSlot()
+			if nextSlot != nil {
+				// 设置下一个任务的信息
+				taskInfo.IsRecording = false
+
+				// 设置时间信息
+				taskInfo.StartTime = timestamppb.New(nextSlot.Start)
+				taskInfo.EndTime = timestamppb.New(nextSlot.End)
+
+				// 计算等待时间
+				waitingDuration := nextSlot.Start.Sub(now)
+				taskInfo.RemainingSeconds = uint32(waitingDuration.Seconds())
+
+				// 设置时间范围和周几
+				startHour := nextSlot.Start.Hour()
+				endHour := nextSlot.End.Hour()
+				taskInfo.TimeRange = fmt.Sprintf("%02d:00-%02d:00", startHour, endHour)
+				taskInfo.Weekday = getWeekdayName(int(nextSlot.Start.Weekday()))
+
+				// 添加到计划任务列表
+				nextTasks = append(nextTasks, taskInfo)
+			}
+		}
+
+		return true // 继续遍历
+	})
+
+	// 如果指定了流路径但未找到对应的任务，查询数据库获取该流的计划信息
+	if req.StreamPath != "" && !streamPathFound {
+		// 查询与该流相关的所有计划
+		var streams []pkg.RecordPlanStream
+		if err := ct.DB.Where("stream_path = ?", req.StreamPath).Find(&streams).Error; err == nil && len(streams) > 0 {
+			for _, stream := range streams {
+				// 获取对应的计划
+				var plan pkg.RecordPlan
+				if err := ct.DB.First(&plan, stream.PlanID).Error; err == nil && plan.Enable && stream.Enable {
+					now := time.Now()
+
+					// 构建任务信息
+					taskInfo := &cronpb.CrontabTaskInfo{
+						PlanId:      uint32(plan.ID),
+						PlanName:    plan.Name,
+						StreamPath:  stream.StreamPath,
+						FilePath:    stream.FilePath,
+						Fragment:    stream.Fragment,
+						IsRecording: false,
+					}
+
+					// 获取完整计划时间段列表
+					planSlots, err := calculateTimeSlots(plan.Plan, now, time.Local)
+					if err == nil && planSlots != nil && len(planSlots) > 0 {
+						taskInfo.PlanSlots = planSlots
+					}
+
+					// 获取下一个时间段
+					nextSlot, err := getNextTimeSlotFromNow(plan.Plan, now, time.Local)
+					if err == nil && nextSlot != nil {
+						// 设置时间信息
+						taskInfo.StartTime = nextSlot.Start
+						taskInfo.EndTime = nextSlot.End
+						taskInfo.TimeRange = nextSlot.TimeRange
+						taskInfo.Weekday = nextSlot.Weekday
+
+						// 计算等待时间
+						waitingDuration := nextSlot.Start.AsTime().Sub(now)
+						taskInfo.RemainingSeconds = uint32(waitingDuration.Seconds())
+
+						// 添加到计划任务列表
+						nextTasks = append(nextTasks, taskInfo)
+					}
+				}
+			}
+		}
+	}
+
+	// 按开始时间排序下一个任务列表
+	sort.Slice(nextTasks, func(i, j int) bool {
+		return nextTasks[i].StartTime.AsTime().Before(nextTasks[j].StartTime.AsTime())
+	})
+
+	// 设置响应结果
+	response.RunningTasks = runningTasks
+	response.NextTasks = nextTasks
+	response.TotalRunning = uint32(len(runningTasks))
+	response.TotalPlanned = uint32(len(nextTasks))
+
+	return response, nil
+}

plugin/crontab/api_test.go

@@ -0,0 +1,244 @@
+package plugin_crontab
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCalculateTimeSlots(t *testing.T) {
+	// 测试案例：周五的凌晨和上午有开启时间段
+	// 字符串中1的索引是120(0点),122(2点),123(3点),125(5点),130(10点),135(15点)
+	// 000000000000000000000000 - 周日(0-23小时) - 全0
+	// 000000000000000000000000 - 周一(24-47小时) - 全0
+	// 000000000000000000000000 - 周二(48-71小时) - 全0
+	// 000000000000000000000000 - 周三(72-95小时) - 全0
+	// 000000000000000000000000 - 周四(96-119小时) - 全0
+	// 101101000010000100000000 - 周五(120-143小时) - 0,2,3,5,10,15点开启
+	// 000000000000000000000000 - 周六(144-167小时) - 全0
+	planStr := "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101101000010000100000000000000000000000000000000"
+
+	now := time.Date(2023, 5, 1, 12, 0, 0, 0, time.Local) // 周一中午
+
+	slots, err := calculateTimeSlots(planStr, now, time.Local)
+	assert.NoError(t, err)
+	assert.Equal(t, 5, len(slots), "应该有5个时间段")
+
+	// 检查结果中的时间段（按实际解析结果排序）
+	assert.Equal(t, "周五", slots[0].Weekday)
+	assert.Equal(t, "10:00-11:00", slots[0].TimeRange)
+
+	assert.Equal(t, "周五", slots[1].Weekday)
+	assert.Equal(t, "15:00-16:00", slots[1].TimeRange)
+
+	assert.Equal(t, "周五", slots[2].Weekday)
+	assert.Equal(t, "00:00-01:00", slots[2].TimeRange)
+
+	assert.Equal(t, "周五", slots[3].Weekday)
+	assert.Equal(t, "02:00-04:00", slots[3].TimeRange)
+
+	assert.Equal(t, "周五", slots[4].Weekday)
+	assert.Equal(t, "05:00-06:00", slots[4].TimeRange)
+
+	// 打印出所有时间段，便于调试
+	for i, slot := range slots {
+		t.Logf("时间段 %d: %s %s", i, slot.Weekday, slot.TimeRange)
+	}
+}
+
+func TestGetNextTimeSlotFromNow(t *testing.T) {
+	// 测试案例：周五的凌晨和上午有开启时间段
+	planStr := "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101101000010000100000000000000000000000000000000"
+
+	// 测试1: 当前是周一，下一个时间段应该是周五凌晨0点
+	now1 := time.Date(2023, 5, 1, 12, 0, 0, 0, time.Local) // 周一中午
+	nextSlot1, err := getNextTimeSlotFromNow(planStr, now1, time.Local)
+	assert.NoError(t, err)
+	assert.NotNil(t, nextSlot1)
+	assert.Equal(t, "周五", nextSlot1.Weekday)
+	assert.Equal(t, "00:00-01:00", nextSlot1.TimeRange)
+
+	// 测试2: 当前是周五凌晨1点，下一个时间段应该是周五凌晨2点
+	now2 := time.Date(2023, 5, 5, 1, 30, 0, 0, time.Local) // 周五凌晨1:30
+	nextSlot2, err := getNextTimeSlotFromNow(planStr, now2, time.Local)
+	assert.NoError(t, err)
+	assert.NotNil(t, nextSlot2)
+	assert.Equal(t, "周五", nextSlot2.Weekday)
+	assert.Equal(t, "02:00-04:00", nextSlot2.TimeRange)
+
+	// 测试3: 当前是周五凌晨3点，此时正在一个时间段内
+	now3 := time.Date(2023, 5, 5, 3, 0, 0, 0, time.Local) // 周五凌晨3:00
+	nextSlot3, err := getNextTimeSlotFromNow(planStr, now3, time.Local)
+	assert.NoError(t, err)
+	assert.NotNil(t, nextSlot3)
+	assert.Equal(t, "周五", nextSlot3.Weekday)
+	assert.Equal(t, "02:00-04:00", nextSlot3.TimeRange)
+}
+
+func TestParsePlanFromString(t *testing.T) {
+	// 测试用户提供的案例：字符串的第36-41位表示周一的时间段
+	// 这个案例中，对应周一的12点、14-15点、17点和22点开启
+	planStr := "000000000000000000000000000000000000101101000010000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+
+	now := time.Now()
+	slots, err := calculateTimeSlots(planStr, now, time.Local)
+	assert.NoError(t, err)
+
+	// 验证解析结果
+	var foundMondaySlots bool
+	for _, slot := range slots {
+		if slot.Weekday == "周一" {
+			foundMondaySlots = true
+			t.Logf("找到周一时间段: %s", slot.TimeRange)
+		}
+	}
+	assert.True(t, foundMondaySlots, "应该找到周一的时间段")
+
+	// 预期的周一时间段
+	var mondaySlots []string
+	for _, slot := range slots {
+		if slot.Weekday == "周一" {
+			mondaySlots = append(mondaySlots, slot.TimeRange)
+		}
+	}
+
+	// 检查是否包含预期的时间段
+	expectedSlots := []string{
+		"12:00-13:00",
+		"14:00-16:00",
+		"17:00-18:00",
+		"22:00-23:00",
+	}
+
+	for _, expected := range expectedSlots {
+		found := false
+		for _, actual := range mondaySlots {
+			if expected == actual {
+				found = true
+				break
+			}
+		}
+		assert.True(t, found, "应该找到周一时间段："+expected)
+	}
+
+	// 获取下一个时间段
+	nextSlot, err := getNextTimeSlotFromNow(planStr, now, time.Local)
+	assert.NoError(t, err)
+	if nextSlot != nil {
+		t.Logf("下一个时间段: %s %s", nextSlot.Weekday, nextSlot.TimeRange)
+	} else {
+		t.Log("没有找到下一个时间段")
+	}
+}
+
+// 手动计算字符串长度的辅助函数
+func TestCountStringLength(t *testing.T) {
+	str1 := "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101101000010000100000000000000000000000000000000"
+	assert.Equal(t, 168, len(str1), "第一个测试字符串长度应为168")
+
+	str2 := "000000000000000000000000000000000000101101000010000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+	assert.Equal(t, 168, len(str2), "第二个测试字符串长度应为168")
+}
+
+// 测试用户提供的具体字符串
+func TestUserProvidedPlanString(t *testing.T) {
+	// 用户提供的测试字符串
+	planStr := "000000000000000000000000000000000000101101000010000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+
+	// 验证字符串长度
+	assert.Equal(t, 168, len(planStr), "字符串长度应为168")
+
+	// 解析时间段
+	now := time.Now()
+	slots, err := calculateTimeSlots(planStr, now, time.Local)
+	assert.NoError(t, err)
+
+	// 打印所有时间段
+	t.Log("所有时间段:")
+	for i, slot := range slots {
+		t.Logf("%d: %s %s", i, slot.Weekday, slot.TimeRange)
+	}
+
+	// 获取下一个时间段
+	nextSlot, err := getNextTimeSlotFromNow(planStr, now, time.Local)
+	assert.NoError(t, err)
+
+	if nextSlot != nil {
+		t.Logf("下一个执行时间段: %s %s", nextSlot.Weekday, nextSlot.TimeRange)
+		t.Logf("开始时间: %s", nextSlot.Start.AsTime().In(time.Local).Format("2006-01-02 15:04:05"))
+		t.Logf("结束时间: %s", nextSlot.End.AsTime().In(time.Local).Format("2006-01-02 15:04:05"))
+	} else {
+		t.Log("没有找到下一个时间段")
+	}
+
+	// 验证周一的时间段
+	var mondaySlots []string
+	for _, slot := range slots {
+		if slot.Weekday == "周一" {
+			mondaySlots = append(mondaySlots, slot.TimeRange)
+		}
+	}
+
+	// 预期周一应该有这些时间段
+	expectedMondaySlots := []string{
+		"12:00-13:00",
+		"14:00-16:00",
+		"17:00-18:00",
+		"22:00-23:00",
+	}
+
+	assert.Equal(t, len(expectedMondaySlots), len(mondaySlots), "周一时间段数量不匹配")
+
+	for i, expected := range expectedMondaySlots {
+		if i < len(mondaySlots) {
+			t.Logf("期望周一时间段 %s, 实际是 %s", expected, mondaySlots[i])
+		}
+	}
+}
+
+// 测试用户提供的第二个字符串
+func TestUserProvidedPlanString2(t *testing.T) {
+	// 用户提供的第二个测试字符串
+	planStr := "000000000000000000000000000000000000000000000000000000000000001011010100001000000000000000000000000100000000000000000000000010000000000000000000000001000000000000000000"
+
+	// 验证字符串长度
+	assert.Equal(t, 168, len(planStr), "字符串长度应为168")
+
+	// 解析时间段
+	now := time.Now()
+	slots, err := calculateTimeSlots(planStr, now, time.Local)
+	assert.NoError(t, err)
+
+	// 打印所有时间段并按周几分组
+	weekdaySlots := make(map[string][]string)
+	for _, slot := range slots {
+		weekdaySlots[slot.Weekday] = append(weekdaySlots[slot.Weekday], slot.TimeRange)
+	}
+
+	t.Log("所有时间段（按周几分组）:")
+	weekdays := []string{"周日", "周一", "周二", "周三", "周四", "周五", "周六"}
+	for _, weekday := range weekdays {
+		if timeRanges, ok := weekdaySlots[weekday]; ok {
+			t.Logf("%s: %v", weekday, timeRanges)
+		}
+	}
+
+	// 打印所有时间段的详细信息
+	t.Log("\n所有时间段详细信息:")
+	for i, slot := range slots {
+		t.Logf("%d: %s %s", i, slot.Weekday, slot.TimeRange)
+	}
+
+	// 获取下一个时间段
+	nextSlot, err := getNextTimeSlotFromNow(planStr, now, time.Local)
+	assert.NoError(t, err)
+
+	if nextSlot != nil {
+		t.Logf("\n下一个执行时间段: %s %s", nextSlot.Weekday, nextSlot.TimeRange)
+		t.Logf("开始时间: %s", nextSlot.Start.AsTime().In(time.Local).Format("2006-01-02 15:04:05"))
+		t.Logf("结束时间: %s", nextSlot.End.AsTime().In(time.Local).Format("2006-01-02 15:04:05"))
+	} else {
+		t.Log("没有找到下一个时间段")
+	}
+}

plugin/crontab/crontab.go

@@ -1,59 +1,422 @@
 package plugin_crontab
 
 import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strconv"
 	"time"
 
 	"m7s.live/v5/pkg/task"
 	"m7s.live/v5/plugin/crontab/pkg"
 )
 
+// 计划时间段
+type TimeSlot struct {
+	Start time.Time // 开始时间
+	End   time.Time // 结束时间
+}
+
+// Crontab 定时任务调度器
 type Crontab struct {
-	task.TickTask
+	task.Job
 	ctp *CrontabPlugin
+	*pkg.RecordPlan
+	*pkg.RecordPlanStream
+
+	stop        chan struct{}
+	running     bool
+	location    *time.Location
+	timer       *time.Timer
+	currentSlot *TimeSlot // 当前执行的时间段
+	recording   bool      // 是否正在录制
 }
 
-func (r *Crontab) GetTickInterval() time.Duration {
-	return time.Minute
+func (cron *Crontab) GetKey() string {
+	return strconv.Itoa(int(cron.PlanID)) + "_" + cron.StreamPath
 }
 
-func (r *Crontab) Tick(any) {
-	r.Info("开始检查录制计划")
-
-	// 获取当前时间
-	now := time.Now()
-	// 计算当前是一周中的第几天(0-6, 0是周日)和当前小时(0-23)
-	weekday := int(now.Weekday())
-	if weekday == 0 {
-		weekday = 7 // 将周日从0改为7，以便计算
-	}
-	hour := now.Hour()
-
-	// 计算当前时间对应的位置索引
-	// (weekday-1)*24 + hour 得到当前时间在144位字符串中的位置
-	// weekday-1 是因为我们要从周一开始计算
-	index := (weekday-1)*24 + hour
-
-	// 查询所有启用的录制计划
-	var plans []pkg.RecordPlan
-	model := pkg.RecordPlan{
-		Enabled: true,
-	}
-	if err := r.ctp.DB.Where(&model).Find(&plans).Error; err != nil {
-		r.Error("查询录制计划失败:", err)
-		return
+// 初始化
+func (cron *Crontab) Start() (err error) {
+	cron.Info("crontab plugin start")
+	if cron.running {
+		return // 已经运行中，不重复启动
 	}
 
-	// 遍历所有计划
-	for _, plan := range plans {
-		if len(plan.Plan) != 168 {
-			r.Error("录制计划格式错误，plan长度应为168位:", plan.Name)
+	// 初始化必要字段
+	if cron.stop == nil {
+		cron.stop = make(chan struct{})
+	}
+	if cron.location == nil {
+		cron.location = time.Local
+	}
+
+	cron.running = true
+
+	return nil
+}
+
+// 阻塞运行
+func (cron *Crontab) Run() (err error) {
+	cron.Info("crontab plugin is running")
+	// 初始化必要字段
+	if cron.stop == nil {
+		cron.stop = make(chan struct{})
+	}
+	if cron.location == nil {
+		cron.location = time.Local
+	}
+
+	cron.Info("调度器启动")
+
+	for {
+		// 获取当前时间
+		now := time.Now().In(cron.location)
+
+		// 首先检查是否需要立即执行操作（如停止录制）
+		if cron.recording && cron.currentSlot != nil &&
+			(now.Equal(cron.currentSlot.End) || now.After(cron.currentSlot.End)) {
+			cron.stopRecording()
 			continue
 		}
 
-		// 检查当前时间对应的位置是否为1
-		if plan.Plan[index] == '1' {
-			r.Info("检测到需要开启录像的计划:", plan.Name)
-			// TODO: 在这里添加开启录像的逻辑
+		// 确定下一个事件
+		var nextEvent time.Time
+		var isStartEvent bool
+
+		if cron.recording {
+			// 如果正在录制，下一个事件是结束时间
+			nextEvent = cron.currentSlot.End
+			isStartEvent = false
+		} else {
+			// 如果没有录制，计算下一个开始时间
+			nextSlot := cron.getNextTimeSlot()
+			if nextSlot == nil {
+				// 无法确定下次执行时间，使用默认间隔
+				cron.timer = time.NewTimer(1 * time.Hour)
+				cron.Info("无有效计划，等待1小时后重试")
+
+				// 等待定时器或停止信号
+				select {
+				case <-cron.timer.C:
+					continue // 继续循环
+				case <-cron.stop:
+					// 停止调度器
+					if cron.timer != nil {
+						cron.timer.Stop()
+					}
+					cron.Info("调度器停止")
+					return
+				}
+			}
+
+			cron.currentSlot = nextSlot
+			nextEvent = nextSlot.Start
+			isStartEvent = true
+
+			// 如果已过开始时间，立即开始录制
+			if now.Equal(nextEvent) || now.After(nextEvent) {
+				cron.startRecording()
+				continue
+			}
+		}
+
+		// 计算等待时间
+		waitDuration := nextEvent.Sub(now)
+
+		// 如果等待时间为负，立即执行
+		if waitDuration <= 0 {
+			if isStartEvent {
+				cron.startRecording()
+			} else {
+				cron.stopRecording()
+			}
+			continue
+		}
+
+		// 设置定时器
+		timer := time.NewTimer(waitDuration)
+
+		if isStartEvent {
+			cron.Info("下次开始时间: ", nextEvent, "等待时间:", waitDuration)
+		} else {
+			cron.Info("下次结束时间: ", nextEvent, " 等待时间:", waitDuration)
+		}
+
+		// 等待定时器或停止信号
+		select {
+		case now = <-timer.C:
+			// 更新当前时间为定时器触发时间
+			now = now.In(cron.location)
+
+			// 执行任务
+			if isStartEvent {
+				cron.startRecording()
+			} else {
+				cron.stopRecording()
+			}
+
+		case <-cron.stop:
+			// 停止调度器
+			timer.Stop()
+			cron.Info("调度器停止")
+			return
+		}
+	}
+}
+
+// 停止
+func (cron *Crontab) Dispose() (err error) {
+	if cron.running {
+		cron.stop <- struct{}{}
+		cron.running = false
+		if cron.timer != nil {
+			cron.timer.Stop()
+		}
+
+		// 如果还在录制，停止录制
+		if cron.recording {
+			cron.stopRecording()
+		}
+	}
+	return
+}
+
+// 获取下一个时间段
+func (cron *Crontab) getNextTimeSlot() *TimeSlot {
+	if cron.RecordPlan == nil || !cron.RecordPlan.Enable || cron.RecordPlan.Plan == "" {
+		return nil // 无有效计划
+	}
+
+	plan := cron.RecordPlan.Plan
+	if len(plan) != 168 {
+		cron.Error("无效的计划格式: %s, 长度应为168", plan)
+		return nil
+	}
+
+	// 使用当地时间
+	now := time.Now().In(cron.location)
+	cron.Debug("当前本地时间: %v, 星期%d, 小时%d", now.Format("2006-01-02 15:04:05"), now.Weekday(), now.Hour())
+
+	// 当前小时
+	currentWeekday := int(now.Weekday())
+	currentHour := now.Hour()
+
+	// 检查是否在整点边界附近(前后30秒)
+	isNearHourBoundary := now.Minute() == 59 && now.Second() >= 30 || now.Minute() == 0 && now.Second() <= 30
+
+	// 首先检查当前时间是否在某个时间段内
+	dayOffset := currentWeekday * 24
+	if currentHour < 24 && plan[dayOffset+currentHour] == '1' {
+		// 找到当前小时所在的完整时间段
+		startHour := currentHour
+		// 向前查找时间段的开始
+		for h := currentHour - 1; h >= 0; h-- {
+			if plan[dayOffset+h] == '1' {
+				startHour = h
+			} else {
+				break
+			}
+		}
+
+		// 向后查找时间段的结束
+		endHour := currentHour + 1
+		for h := endHour; h < 24; h++ {
+			if plan[dayOffset+h] == '1' {
+				endHour = h + 1
+			} else {
+				break
+			}
+		}
+
+		// 检查我们是否已经接近当前时间段的结束
+		isNearEndOfTimeSlot := currentHour == endHour-1 && now.Minute() == 59 && now.Second() >= 30
+
+		// 如果我们靠近时间段结束且在小时边界附近，我们跳过此时间段，找下一个
+		if isNearEndOfTimeSlot && isNearHourBoundary {
+			cron.Debug("接近当前时间段结束，准备查找下一个时间段")
+		} else {
+			// 创建时间段
+			startTime := time.Date(now.Year(), now.Month(), now.Day(), startHour, 0, 0, 0, cron.location)
+			endTime := time.Date(now.Year(), now.Month(), now.Day(), endHour, 0, 0, 0, cron.location)
+
+			// 如果当前时间已经接近或超过了结束时间，调整结束时间
+			if now.After(endTime.Add(-30*time.Second)) || now.Equal(endTime) {
+				cron.Debug("当前时间已接近或超过结束时间，尝试查找下一个时间段")
+			} else {
+				cron.Debug("当前已在有效时间段内: 开始=%v, 结束=%v",
+					startTime.Format("2006-01-02 15:04:05"), endTime.Format("2006-01-02 15:04:05"))
+
+				return &TimeSlot{
+					Start: startTime,
+					End:   endTime,
+				}
+			}
+		}
+	}
+
+	// 查找下一个时间段
+	// 先查找当天剩余时间
+	for h := currentHour + 1; h < 24; h++ {
+		if plan[dayOffset+h] == '1' {
+			// 找到开始小时
+			startHour := h
+			// 查找结束小时
+			endHour := h + 1
+			for j := h + 1; j < 24; j++ {
+				if plan[dayOffset+j] == '1' {
+					endHour = j + 1
+				} else {
+					break
+				}
+			}
+
+			// 创建时间段
+			startTime := time.Date(now.Year(), now.Month(), now.Day(), startHour, 0, 0, 0, cron.location)
+			endTime := time.Date(now.Year(), now.Month(), now.Day(), endHour, 0, 0, 0, cron.location)
+
+			cron.Debug("找到今天的有效时间段: 开始=%v, 结束=%v",
+				startTime.Format("2006-01-02 15:04:05"), endTime.Format("2006-01-02 15:04:05"))
+
+			return &TimeSlot{
+				Start: startTime,
+				End:   endTime,
+			}
+		}
+	}
+
+	// 如果当天没有找到，则查找后续日期
+	for d := 1; d <= 7; d++ {
+		nextDay := (currentWeekday + d) % 7
+		dayOffset := nextDay * 24
+
+		for h := 0; h < 24; h++ {
+			if plan[dayOffset+h] == '1' {
+				// 找到开始小时
+				startHour := h
+				// 查找结束小时
+				endHour := h + 1
+				for j := h + 1; j < 24; j++ {
+					if plan[dayOffset+j] == '1' {
+						endHour = j + 1
+					} else {
+						break
+					}
+				}
+
+				// 计算日期
+				nextDate := now.AddDate(0, 0, d)
+
+				// 创建时间段
+				startTime := time.Date(nextDate.Year(), nextDate.Month(), nextDate.Day(), startHour, 0, 0, 0, cron.location)
+				endTime := time.Date(nextDate.Year(), nextDate.Month(), nextDate.Day(), endHour, 0, 0, 0, cron.location)
+
+				cron.Debug("找到未来有效时间段: 开始=%v, 结束=%v",
+					startTime.Format("2006-01-02 15:04:05"), endTime.Format("2006-01-02 15:04:05"))
+
+				return &TimeSlot{
+					Start: startTime,
+					End:   endTime,
+				}
+			}
+		}
+	}
+
+	cron.Debug("未找到有效的时间段")
+	return nil
+}
+
+// 开始录制
+func (cron *Crontab) startRecording() {
+	if cron.recording {
+		return // 已经在录制了
+	}
+
+	now := time.Now().In(cron.location)
+	cron.Info("开始录制任务: %s, 时间: %v, 计划结束时间: %v",
+		cron.RecordPlan.Name, now, cron.currentSlot.End)
+
+	// 构造请求体
+	reqBody := map[string]string{
+		"fragment": cron.Fragment,
+		"filePath": cron.FilePath,
+	}
+	jsonBody, err := json.Marshal(reqBody)
+	if err != nil {
+		cron.Error("构造请求体失败: %v", err)
+		return
+	}
+
+	// 获取 HTTP 地址
+	addr := cron.ctp.Plugin.GetCommonConf().HTTP.ListenAddr
+	if addr == "" {
+		addr = ":8080" // 使用默认端口
+	}
+	if addr[0] == ':' {
+		addr = "localhost" + addr
+	}
+
+	// 发送开始录制请求
+	resp, err := http.Post(fmt.Sprintf("http://%s/mp4/api/start/%s", addr, cron.StreamPath), "application/json", bytes.NewBuffer(jsonBody))
+	if err != nil {
+		cron.Error("开始录制失败: %v", err)
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		cron.Error("开始录制失败，HTTP状态码: %d", resp.StatusCode)
+		return
+	}
+
+	cron.recording = true
+}
+
+// 停止录制
+func (cron *Crontab) stopRecording() {
+	if !cron.recording {
+		return // 没有在录制
+	}
+
+	// 立即记录当前时间并重置状态，避免重复调用
+	now := time.Now().In(cron.location)
+	cron.Info("停止录制任务: %s, 时间: %v", cron.RecordPlan.Name, now)
+
+	// 先重置状态，避免循环中重复检测到停止条件
+	wasRecording := cron.recording
+	cron.recording = false
+	savedSlot := cron.currentSlot
+	cron.currentSlot = nil
+
+	// 获取 HTTP 地址
+	addr := cron.ctp.Plugin.GetCommonConf().HTTP.ListenAddr
+	if addr == "" {
+		addr = ":8080" // 使用默认端口
+	}
+	if addr[0] == ':' {
+		addr = "localhost" + addr
+	}
+
+	// 发送停止录制请求
+	resp, err := http.Post(fmt.Sprintf("http://%s/mp4/api/stop/%s", addr, cron.StreamPath), "application/json", nil)
+	if err != nil {
+		cron.Error("停止录制失败: %v", err)
+		// 如果请求失败，恢复状态以便下次重试
+		if wasRecording {
+			cron.recording = true
+			cron.currentSlot = savedSlot
+		}
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		cron.Error("停止录制失败，HTTP状态码: %d", resp.StatusCode)
+		// 如果请求失败，恢复状态以便下次重试
+		if wasRecording {
+			cron.recording = true
+			cron.currentSlot = savedSlot
 		}
 	}
 }

plugin/crontab/index.go

@@ -3,6 +3,8 @@ package plugin_crontab
 import (
 	"fmt"
 
+	"m7s.live/v5/pkg/util"
+
 	"m7s.live/v5"
 	"m7s.live/v5/plugin/crontab/pb"
 	"m7s.live/v5/plugin/crontab/pkg"
@@ -11,6 +13,8 @@ import (
 type CrontabPlugin struct {
 	m7s.Plugin
 	pb.UnimplementedApiServer
+	crontabs    util.Collection[string, *Crontab]
+	recordPlans util.Collection[uint, *pkg.RecordPlan]
 }
 
 var _ = m7s.InstallPlugin[CrontabPlugin](m7s.PluginMeta{
@@ -22,14 +26,46 @@ func (ct *CrontabPlugin) OnInit() (err error) {
 	if ct.DB == nil {
 		ct.Error("DB is nil")
 	} else {
-		err = ct.DB.AutoMigrate(&pkg.RecordPlan{})
+		err = ct.DB.AutoMigrate(&pkg.RecordPlan{}, &pkg.RecordPlanStream{})
 		if err != nil {
 			return fmt.Errorf("auto migrate tables error: %v", err)
 		}
 		ct.Info("init database success")
+
+		// 查询所有录制计划
+		var plans []pkg.RecordPlan
+		if err = ct.DB.Find(&plans).Error; err != nil {
+			return fmt.Errorf("query record plans error: %v", err)
+		}
+
+		// 遍历所有计划
+		for _, plan := range plans {
+			// 将计划存入 recordPlans 集合
+			ct.recordPlans.Add(&plan)
+
+			// 如果计划已启用，查询对应的流信息并创建定时任务
+			if plan.Enable {
+				var streams []pkg.RecordPlanStream
+				model := &pkg.RecordPlanStream{PlanID: plan.ID}
+				if err = ct.DB.Model(model).Where(model).Find(&streams).Error; err != nil {
+					ct.Error("query record plan streams error: %v", err)
+					continue
+				}
+
+				// 为每个流创建定时任务
+				for _, stream := range streams {
+					crontab := &Crontab{
+						ctp:              ct,
+						RecordPlan:       &plan,
+						RecordPlanStream: &stream,
+					}
+					crontab.OnStart(func() {
+						ct.crontabs.Set(crontab)
+					})
+					ct.AddTask(crontab)
+				}
+			}
+		}
 	}
-	crontab := &Crontab{ctp: ct}
-	ct.AddTask(crontab)
-	crontab.Tick(nil)
 	return
 }

plugin/crontab/pb/crontab.pb.go

@@ -339,6 +339,767 @@ func (x *Response) GetMessage() string {
 	return ""
 }
 
+// RecordPlanStream 相关消息定义
+type PlanStream struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	PlanId        uint32                 `protobuf:"varint,1,opt,name=planId,proto3" json:"planId,omitempty"`
+	StreamPath    string                 `protobuf:"bytes,2,opt,name=stream_path,json=streamPath,proto3" json:"stream_path,omitempty"`
+	Fragment      string                 `protobuf:"bytes,3,opt,name=fragment,proto3" json:"fragment,omitempty"`
+	FilePath      string                 `protobuf:"bytes,4,opt,name=filePath,proto3" json:"filePath,omitempty"`
+	RecordType    string                 `protobuf:"bytes,5,opt,name=record_type,json=recordType,proto3" json:"record_type,omitempty"` // 录制类型，例如 "mp4", "flv"
+	CreatedAt     *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
+	UpdatedAt     *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
+	Enable        bool                   `protobuf:"varint,8,opt,name=enable,proto3" json:"enable,omitempty"` // 是否启用该录制流
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *PlanStream) Reset() {
+	*x = PlanStream{}
+	mi := &file_crontab_proto_msgTypes[5]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *PlanStream) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PlanStream) ProtoMessage() {}
+
+func (x *PlanStream) ProtoReflect() protoreflect.Message {
+	mi := &file_crontab_proto_msgTypes[5]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use PlanStream.ProtoReflect.Descriptor instead.
+func (*PlanStream) Descriptor() ([]byte, []int) {
+	return file_crontab_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *PlanStream) GetPlanId() uint32 {
+	if x != nil {
+		return x.PlanId
+	}
+	return 0
+}
+
+func (x *PlanStream) GetStreamPath() string {
+	if x != nil {
+		return x.StreamPath
+	}
+	return ""
+}
+
+func (x *PlanStream) GetFragment() string {
+	if x != nil {
+		return x.Fragment
+	}
+	return ""
+}
+
+func (x *PlanStream) GetFilePath() string {
+	if x != nil {
+		return x.FilePath
+	}
+	return ""
+}
+
+func (x *PlanStream) GetRecordType() string {
+	if x != nil {
+		return x.RecordType
+	}
+	return ""
+}
+
+func (x *PlanStream) GetCreatedAt() *timestamppb.Timestamp {
+	if x != nil {
+		return x.CreatedAt
+	}
+	return nil
+}
+
+func (x *PlanStream) GetUpdatedAt() *timestamppb.Timestamp {
+	if x != nil {
+		return x.UpdatedAt
+	}
+	return nil
+}
+
+func (x *PlanStream) GetEnable() bool {
+	if x != nil {
+		return x.Enable
+	}
+	return false
+}
+
+type ReqPlanStreamList struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	PageNum       uint32                 `protobuf:"varint,1,opt,name=pageNum,proto3" json:"pageNum,omitempty"`
+	PageSize      uint32                 `protobuf:"varint,2,opt,name=pageSize,proto3" json:"pageSize,omitempty"`
+	PlanId        uint32                 `protobuf:"varint,3,opt,name=planId,proto3" json:"planId,omitempty"`                          // 可选的按录制计划ID筛选
+	StreamPath    string                 `protobuf:"bytes,4,opt,name=stream_path,json=streamPath,proto3" json:"stream_path,omitempty"` // 可选的按流路径筛选
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *ReqPlanStreamList) Reset() {
+	*x = ReqPlanStreamList{}
+	mi := &file_crontab_proto_msgTypes[6]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ReqPlanStreamList) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ReqPlanStreamList) ProtoMessage() {}
+
+func (x *ReqPlanStreamList) ProtoReflect() protoreflect.Message {
+	mi := &file_crontab_proto_msgTypes[6]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ReqPlanStreamList.ProtoReflect.Descriptor instead.
+func (*ReqPlanStreamList) Descriptor() ([]byte, []int) {
+	return file_crontab_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *ReqPlanStreamList) GetPageNum() uint32 {
+	if x != nil {
+		return x.PageNum
+	}
+	return 0
+}
+
+func (x *ReqPlanStreamList) GetPageSize() uint32 {
+	if x != nil {
+		return x.PageSize
+	}
+	return 0
+}
+
+func (x *ReqPlanStreamList) GetPlanId() uint32 {
+	if x != nil {
+		return x.PlanId
+	}
+	return 0
+}
+
+func (x *ReqPlanStreamList) GetStreamPath() string {
+	if x != nil {
+		return x.StreamPath
+	}
+	return ""
+}
+
+type RecordPlanStreamResponseList struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Code          int32                  `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
+	Message       string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
+	TotalCount    uint32                 `protobuf:"varint,3,opt,name=totalCount,proto3" json:"totalCount,omitempty"`
+	PageNum       uint32                 `protobuf:"varint,4,opt,name=pageNum,proto3" json:"pageNum,omitempty"`
+	PageSize      uint32                 `protobuf:"varint,5,opt,name=pageSize,proto3" json:"pageSize,omitempty"`
+	Data          []*PlanStream          `protobuf:"bytes,6,rep,name=data,proto3" json:"data,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *RecordPlanStreamResponseList) Reset() {
+	*x = RecordPlanStreamResponseList{}
+	mi := &file_crontab_proto_msgTypes[7]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *RecordPlanStreamResponseList) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RecordPlanStreamResponseList) ProtoMessage() {}
+
+func (x *RecordPlanStreamResponseList) ProtoReflect() protoreflect.Message {
+	mi := &file_crontab_proto_msgTypes[7]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RecordPlanStreamResponseList.ProtoReflect.Descriptor instead.
+func (*RecordPlanStreamResponseList) Descriptor() ([]byte, []int) {
+	return file_crontab_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *RecordPlanStreamResponseList) GetCode() int32 {
+	if x != nil {
+		return x.Code
+	}
+	return 0
+}
+
+func (x *RecordPlanStreamResponseList) GetMessage() string {
+	if x != nil {
+		return x.Message
+	}
+	return ""
+}
+
+func (x *RecordPlanStreamResponseList) GetTotalCount() uint32 {
+	if x != nil {
+		return x.TotalCount
+	}
+	return 0
+}
+
+func (x *RecordPlanStreamResponseList) GetPageNum() uint32 {
+	if x != nil {
+		return x.PageNum
+	}
+	return 0
+}
+
+func (x *RecordPlanStreamResponseList) GetPageSize() uint32 {
+	if x != nil {
+		return x.PageSize
+	}
+	return 0
+}
+
+func (x *RecordPlanStreamResponseList) GetData() []*PlanStream {
+	if x != nil {
+		return x.Data
+	}
+	return nil
+}
+
+type DeletePlanStreamRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	PlanId        uint32                 `protobuf:"varint,1,opt,name=planId,proto3" json:"planId,omitempty"`
+	StreamPath    string                 `protobuf:"bytes,2,opt,name=streamPath,proto3" json:"streamPath,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *DeletePlanStreamRequest) Reset() {
+	*x = DeletePlanStreamRequest{}
+	mi := &file_crontab_proto_msgTypes[8]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *DeletePlanStreamRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DeletePlanStreamRequest) ProtoMessage() {}
+
+func (x *DeletePlanStreamRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_crontab_proto_msgTypes[8]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DeletePlanStreamRequest.ProtoReflect.Descriptor instead.
+func (*DeletePlanStreamRequest) Descriptor() ([]byte, []int) {
+	return file_crontab_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *DeletePlanStreamRequest) GetPlanId() uint32 {
+	if x != nil {
+		return x.PlanId
+	}
+	return 0
+}
+
+func (x *DeletePlanStreamRequest) GetStreamPath() string {
+	if x != nil {
+		return x.StreamPath
+	}
+	return ""
+}
+
+// 解析计划请求
+type ParsePlanRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Plan          string                 `protobuf:"bytes,1,opt,name=plan,proto3" json:"plan,omitempty"` // 168位的0/1字符串，表示一周的每个小时是否录制
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *ParsePlanRequest) Reset() {
+	*x = ParsePlanRequest{}
+	mi := &file_crontab_proto_msgTypes[9]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ParsePlanRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ParsePlanRequest) ProtoMessage() {}
+
+func (x *ParsePlanRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_crontab_proto_msgTypes[9]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ParsePlanRequest.ProtoReflect.Descriptor instead.
+func (*ParsePlanRequest) Descriptor() ([]byte, []int) {
+	return file_crontab_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *ParsePlanRequest) GetPlan() string {
+	if x != nil {
+		return x.Plan
+	}
+	return ""
+}
+
+// 时间段信息
+type TimeSlotInfo struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Start         *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=start,proto3" json:"start,omitempty"`                          // 开始时间
+	End           *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=end,proto3" json:"end,omitempty"`                              // 结束时间
+	Weekday       string                 `protobuf:"bytes,3,opt,name=weekday,proto3" json:"weekday,omitempty"`                      // 周几（例如：周一）
+	TimeRange     string                 `protobuf:"bytes,4,opt,name=time_range,json=timeRange,proto3" json:"time_range,omitempty"` // 时间范围（例如：09:00-10:00）
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *TimeSlotInfo) Reset() {
+	*x = TimeSlotInfo{}
+	mi := &file_crontab_proto_msgTypes[10]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *TimeSlotInfo) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TimeSlotInfo) ProtoMessage() {}
+
+func (x *TimeSlotInfo) ProtoReflect() protoreflect.Message {
+	mi := &file_crontab_proto_msgTypes[10]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TimeSlotInfo.ProtoReflect.Descriptor instead.
+func (*TimeSlotInfo) Descriptor() ([]byte, []int) {
+	return file_crontab_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *TimeSlotInfo) GetStart() *timestamppb.Timestamp {
+	if x != nil {
+		return x.Start
+	}
+	return nil
+}
+
+func (x *TimeSlotInfo) GetEnd() *timestamppb.Timestamp {
+	if x != nil {
+		return x.End
+	}
+	return nil
+}
+
+func (x *TimeSlotInfo) GetWeekday() string {
+	if x != nil {
+		return x.Weekday
+	}
+	return ""
+}
+
+func (x *TimeSlotInfo) GetTimeRange() string {
+	if x != nil {
+		return x.TimeRange
+	}
+	return ""
+}
+
+// 解析计划响应
+type ParsePlanResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Code          int32                  `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`                        // 响应码
+	Message       string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`                   // 响应消息
+	Slots         []*TimeSlotInfo        `protobuf:"bytes,3,rep,name=slots,proto3" json:"slots,omitempty"`                       // 所有计划的时间段
+	NextSlot      *TimeSlotInfo          `protobuf:"bytes,4,opt,name=next_slot,json=nextSlot,proto3" json:"next_slot,omitempty"` // 从当前时间开始的下一个时间段
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *ParsePlanResponse) Reset() {
+	*x = ParsePlanResponse{}
+	mi := &file_crontab_proto_msgTypes[11]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ParsePlanResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ParsePlanResponse) ProtoMessage() {}
+
+func (x *ParsePlanResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_crontab_proto_msgTypes[11]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ParsePlanResponse.ProtoReflect.Descriptor instead.
+func (*ParsePlanResponse) Descriptor() ([]byte, []int) {
+	return file_crontab_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *ParsePlanResponse) GetCode() int32 {
+	if x != nil {
+		return x.Code
+	}
+	return 0
+}
+
+func (x *ParsePlanResponse) GetMessage() string {
+	if x != nil {
+		return x.Message
+	}
+	return ""
+}
+
+func (x *ParsePlanResponse) GetSlots() []*TimeSlotInfo {
+	if x != nil {
+		return x.Slots
+	}
+	return nil
+}
+
+func (x *ParsePlanResponse) GetNextSlot() *TimeSlotInfo {
+	if x != nil {
+		return x.NextSlot
+	}
+	return nil
+}
+
+// 新增的消息定义
+// 获取Crontab状态请求
+type CrontabStatusRequest struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// 可以为空，表示获取所有任务
+	StreamPath    string `protobuf:"bytes,1,opt,name=stream_path,json=streamPath,proto3" json:"stream_path,omitempty"` // 可选，按流路径过滤
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *CrontabStatusRequest) Reset() {
+	*x = CrontabStatusRequest{}
+	mi := &file_crontab_proto_msgTypes[12]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *CrontabStatusRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CrontabStatusRequest) ProtoMessage() {}
+
+func (x *CrontabStatusRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_crontab_proto_msgTypes[12]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CrontabStatusRequest.ProtoReflect.Descriptor instead.
+func (*CrontabStatusRequest) Descriptor() ([]byte, []int) {
+	return file_crontab_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *CrontabStatusRequest) GetStreamPath() string {
+	if x != nil {
+		return x.StreamPath
+	}
+	return ""
+}
+
+// 任务信息
+type CrontabTaskInfo struct {
+	state            protoimpl.MessageState `protogen:"open.v1"`
+	PlanId           uint32                 `protobuf:"varint,1,opt,name=plan_id,json=planId,proto3" json:"plan_id,omitempty"`                                // 计划ID
+	PlanName         string                 `protobuf:"bytes,2,opt,name=plan_name,json=planName,proto3" json:"plan_name,omitempty"`                           // 计划名称
+	StreamPath       string                 `protobuf:"bytes,3,opt,name=stream_path,json=streamPath,proto3" json:"stream_path,omitempty"`                     // 流路径
+	IsRecording      bool                   `protobuf:"varint,4,opt,name=is_recording,json=isRecording,proto3" json:"is_recording,omitempty"`                 // 是否正在录制
+	StartTime        *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`                        // 当前/下一个任务开始时间
+	EndTime          *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`                              // 当前/下一个任务结束时间
+	TimeRange        string                 `protobuf:"bytes,7,opt,name=time_range,json=timeRange,proto3" json:"time_range,omitempty"`                        // 时间范围（例如：09:00-10:00）
+	Weekday          string                 `protobuf:"bytes,8,opt,name=weekday,proto3" json:"weekday,omitempty"`                                             // 周几（例如：周一）
+	FilePath         string                 `protobuf:"bytes,9,opt,name=file_path,json=filePath,proto3" json:"file_path,omitempty"`                           // 文件保存路径
+	Fragment         string                 `protobuf:"bytes,10,opt,name=fragment,proto3" json:"fragment,omitempty"`                                          // 分片设置
+	ElapsedSeconds   uint32                 `protobuf:"varint,11,opt,name=elapsed_seconds,json=elapsedSeconds,proto3" json:"elapsed_seconds,omitempty"`       // 已运行时间（秒，仅对正在运行的任务有效）
+	RemainingSeconds uint32                 `protobuf:"varint,12,opt,name=remaining_seconds,json=remainingSeconds,proto3" json:"remaining_seconds,omitempty"` // 剩余时间（秒）
+	PlanSlots        []*TimeSlotInfo        `protobuf:"bytes,13,rep,name=plan_slots,json=planSlots,proto3" json:"plan_slots,omitempty"`                       // 完整的计划时间段列表
+	unknownFields    protoimpl.UnknownFields
+	sizeCache        protoimpl.SizeCache
+}
+
+func (x *CrontabTaskInfo) Reset() {
+	*x = CrontabTaskInfo{}
+	mi := &file_crontab_proto_msgTypes[13]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *CrontabTaskInfo) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CrontabTaskInfo) ProtoMessage() {}
+
+func (x *CrontabTaskInfo) ProtoReflect() protoreflect.Message {
+	mi := &file_crontab_proto_msgTypes[13]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CrontabTaskInfo.ProtoReflect.Descriptor instead.
+func (*CrontabTaskInfo) Descriptor() ([]byte, []int) {
+	return file_crontab_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *CrontabTaskInfo) GetPlanId() uint32 {
+	if x != nil {
+		return x.PlanId
+	}
+	return 0
+}
+
+func (x *CrontabTaskInfo) GetPlanName() string {
+	if x != nil {
+		return x.PlanName
+	}
+	return ""
+}
+
+func (x *CrontabTaskInfo) GetStreamPath() string {
+	if x != nil {
+		return x.StreamPath
+	}
+	return ""
+}
+
+func (x *CrontabTaskInfo) GetIsRecording() bool {
+	if x != nil {
+		return x.IsRecording
+	}
+	return false
+}
+
+func (x *CrontabTaskInfo) GetStartTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.StartTime
+	}
+	return nil
+}
+
+func (x *CrontabTaskInfo) GetEndTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.EndTime
+	}
+	return nil
+}
+
+func (x *CrontabTaskInfo) GetTimeRange() string {
+	if x != nil {
+		return x.TimeRange
+	}
+	return ""
+}
+
+func (x *CrontabTaskInfo) GetWeekday() string {
+	if x != nil {
+		return x.Weekday
+	}
+	return ""
+}
+
+func (x *CrontabTaskInfo) GetFilePath() string {
+	if x != nil {
+		return x.FilePath
+	}
+	return ""
+}
+
+func (x *CrontabTaskInfo) GetFragment() string {
+	if x != nil {
+		return x.Fragment
+	}
+	return ""
+}
+
+func (x *CrontabTaskInfo) GetElapsedSeconds() uint32 {
+	if x != nil {
+		return x.ElapsedSeconds
+	}
+	return 0
+}
+
+func (x *CrontabTaskInfo) GetRemainingSeconds() uint32 {
+	if x != nil {
+		return x.RemainingSeconds
+	}
+	return 0
+}
+
+func (x *CrontabTaskInfo) GetPlanSlots() []*TimeSlotInfo {
+	if x != nil {
+		return x.PlanSlots
+	}
+	return nil
+}
+
+// 获取Crontab状态响应
+type CrontabStatusResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Code          int32                  `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`                                     // 响应码
+	Message       string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`                                // 响应消息
+	RunningTasks  []*CrontabTaskInfo     `protobuf:"bytes,3,rep,name=running_tasks,json=runningTasks,proto3" json:"running_tasks,omitempty"`  // 当前正在执行的任务列表
+	NextTasks     []*CrontabTaskInfo     `protobuf:"bytes,4,rep,name=next_tasks,json=nextTasks,proto3" json:"next_tasks,omitempty"`           // 下一个计划执行的任务列表
+	TotalRunning  uint32                 `protobuf:"varint,5,opt,name=total_running,json=totalRunning,proto3" json:"total_running,omitempty"` // 正在运行的任务总数
+	TotalPlanned  uint32                 `protobuf:"varint,6,opt,name=total_planned,json=totalPlanned,proto3" json:"total_planned,omitempty"` // 计划中的任务总数
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *CrontabStatusResponse) Reset() {
+	*x = CrontabStatusResponse{}
+	mi := &file_crontab_proto_msgTypes[14]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *CrontabStatusResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CrontabStatusResponse) ProtoMessage() {}
+
+func (x *CrontabStatusResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_crontab_proto_msgTypes[14]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CrontabStatusResponse.ProtoReflect.Descriptor instead.
+func (*CrontabStatusResponse) Descriptor() ([]byte, []int) {
+	return file_crontab_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *CrontabStatusResponse) GetCode() int32 {
+	if x != nil {
+		return x.Code
+	}
+	return 0
+}
+
+func (x *CrontabStatusResponse) GetMessage() string {
+	if x != nil {
+		return x.Message
+	}
+	return ""
+}
+
+func (x *CrontabStatusResponse) GetRunningTasks() []*CrontabTaskInfo {
+	if x != nil {
+		return x.RunningTasks
+	}
+	return nil
+}
+
+func (x *CrontabStatusResponse) GetNextTasks() []*CrontabTaskInfo {
+	if x != nil {
+		return x.NextTasks
+	}
+	return nil
+}
+
+func (x *CrontabStatusResponse) GetTotalRunning() uint32 {
+	if x != nil {
+		return x.TotalRunning
+	}
+	return 0
+}
+
+func (x *CrontabStatusResponse) GetTotalPlanned() uint32 {
+	if x != nil {
+		return x.TotalPlanned
+	}
+	return 0
+}
+
 var File_crontab_proto protoreflect.FileDescriptor
 
 const file_crontab_proto_rawDesc = "" +
@@ -371,12 +1132,95 @@ const file_crontab_proto_rawDesc = "" +
 	"\x02id\x18\x01 \x01(\rR\x02id\"8\n" +
 	"\bResponse\x12\x12\n" +
 	"\x04code\x18\x01 \x01(\x05R\x04code\x12\x18\n" +
-	"\amessage\x18\x02 \x01(\tR\amessage2\xbe\x02\n" +
+	"\amessage\x18\x02 \x01(\tR\amessage\"\xac\x02\n" +
+	"\n" +
+	"PlanStream\x12\x16\n" +
+	"\x06planId\x18\x01 \x01(\rR\x06planId\x12\x1f\n" +
+	"\vstream_path\x18\x02 \x01(\tR\n" +
+	"streamPath\x12\x1a\n" +
+	"\bfragment\x18\x03 \x01(\tR\bfragment\x12\x1a\n" +
+	"\bfilePath\x18\x04 \x01(\tR\bfilePath\x12\x1f\n" +
+	"\vrecord_type\x18\x05 \x01(\tR\n" +
+	"recordType\x129\n" +
+	"\n" +
+	"created_at\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\tcreatedAt\x129\n" +
+	"\n" +
+	"updated_at\x18\a \x01(\v2\x1a.google.protobuf.TimestampR\tupdatedAt\x12\x16\n" +
+	"\x06enable\x18\b \x01(\bR\x06enable\"\x82\x01\n" +
+	"\x11ReqPlanStreamList\x12\x18\n" +
+	"\apageNum\x18\x01 \x01(\rR\apageNum\x12\x1a\n" +
+	"\bpageSize\x18\x02 \x01(\rR\bpageSize\x12\x16\n" +
+	"\x06planId\x18\x03 \x01(\rR\x06planId\x12\x1f\n" +
+	"\vstream_path\x18\x04 \x01(\tR\n" +
+	"streamPath\"\xcb\x01\n" +
+	"\x1cRecordPlanStreamResponseList\x12\x12\n" +
+	"\x04code\x18\x01 \x01(\x05R\x04code\x12\x18\n" +
+	"\amessage\x18\x02 \x01(\tR\amessage\x12\x1e\n" +
+	"\n" +
+	"totalCount\x18\x03 \x01(\rR\n" +
+	"totalCount\x12\x18\n" +
+	"\apageNum\x18\x04 \x01(\rR\apageNum\x12\x1a\n" +
+	"\bpageSize\x18\x05 \x01(\rR\bpageSize\x12'\n" +
+	"\x04data\x18\x06 \x03(\v2\x13.crontab.PlanStreamR\x04data\"Q\n" +
+	"\x17DeletePlanStreamRequest\x12\x16\n" +
+	"\x06planId\x18\x01 \x01(\rR\x06planId\x12\x1e\n" +
+	"\n" +
+	"streamPath\x18\x02 \x01(\tR\n" +
+	"streamPath\"&\n" +
+	"\x10ParsePlanRequest\x12\x12\n" +
+	"\x04plan\x18\x01 \x01(\tR\x04plan\"\xa7\x01\n" +
+	"\fTimeSlotInfo\x120\n" +
+	"\x05start\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\x05start\x12,\n" +
+	"\x03end\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\x03end\x12\x18\n" +
+	"\aweekday\x18\x03 \x01(\tR\aweekday\x12\x1d\n" +
+	"\n" +
+	"time_range\x18\x04 \x01(\tR\ttimeRange\"\xa2\x01\n" +
+	"\x11ParsePlanResponse\x12\x12\n" +
+	"\x04code\x18\x01 \x01(\x05R\x04code\x12\x18\n" +
+	"\amessage\x18\x02 \x01(\tR\amessage\x12+\n" +
+	"\x05slots\x18\x03 \x03(\v2\x15.crontab.TimeSlotInfoR\x05slots\x122\n" +
+	"\tnext_slot\x18\x04 \x01(\v2\x15.crontab.TimeSlotInfoR\bnextSlot\"7\n" +
+	"\x14CrontabStatusRequest\x12\x1f\n" +
+	"\vstream_path\x18\x01 \x01(\tR\n" +
+	"streamPath\"\xfb\x03\n" +
+	"\x0fCrontabTaskInfo\x12\x17\n" +
+	"\aplan_id\x18\x01 \x01(\rR\x06planId\x12\x1b\n" +
+	"\tplan_name\x18\x02 \x01(\tR\bplanName\x12\x1f\n" +
+	"\vstream_path\x18\x03 \x01(\tR\n" +
+	"streamPath\x12!\n" +
+	"\fis_recording\x18\x04 \x01(\bR\visRecording\x129\n" +
+	"\n" +
+	"start_time\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\tstartTime\x125\n" +
+	"\bend_time\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\aendTime\x12\x1d\n" +
+	"\n" +
+	"time_range\x18\a \x01(\tR\ttimeRange\x12\x18\n" +
+	"\aweekday\x18\b \x01(\tR\aweekday\x12\x1b\n" +
+	"\tfile_path\x18\t \x01(\tR\bfilePath\x12\x1a\n" +
+	"\bfragment\x18\n" +
+	" \x01(\tR\bfragment\x12'\n" +
+	"\x0felapsed_seconds\x18\v \x01(\rR\x0eelapsedSeconds\x12+\n" +
+	"\x11remaining_seconds\x18\f \x01(\rR\x10remainingSeconds\x124\n" +
+	"\n" +
+	"plan_slots\x18\r \x03(\v2\x15.crontab.TimeSlotInfoR\tplanSlots\"\x87\x02\n" +
+	"\x15CrontabStatusResponse\x12\x12\n" +
+	"\x04code\x18\x01 \x01(\x05R\x04code\x12\x18\n" +
+	"\amessage\x18\x02 \x01(\tR\amessage\x12=\n" +
+	"\rrunning_tasks\x18\x03 \x03(\v2\x18.crontab.CrontabTaskInfoR\frunningTasks\x127\n" +
+	"\n" +
+	"next_tasks\x18\x04 \x03(\v2\x18.crontab.CrontabTaskInfoR\tnextTasks\x12#\n" +
+	"\rtotal_running\x18\x05 \x01(\rR\ftotalRunning\x12#\n" +
+	"\rtotal_planned\x18\x06 \x01(\rR\ftotalPlanned2\xe0\a\n" +
 	"\x03api\x12O\n" +
 	"\x04List\x12\x14.crontab.ReqPlanList\x1a\x19.crontab.PlanResponseList\"\x16\x82\xd3\xe4\x93\x02\x10\x12\x0e/plan/api/list\x12A\n" +
 	"\x03Add\x12\r.crontab.Plan\x1a\x11.crontab.Response\"\x18\x82\xd3\xe4\x93\x02\x12:\x01*\"\r/plan/api/add\x12L\n" +
 	"\x06Update\x12\r.crontab.Plan\x1a\x11.crontab.Response\" \x82\xd3\xe4\x93\x02\x1a:\x01*\"\x15/plan/api/update/{id}\x12U\n" +
-	"\x06Remove\x12\x16.crontab.DeleteRequest\x1a\x11.crontab.Response\" \x82\xd3\xe4\x93\x02\x1a:\x01*\"\x15/plan/api/remove/{id}B\x1fZ\x1dm7s.live/v5/plugin/crontab/pbb\x06proto3"
+	"\x06Remove\x12\x16.crontab.DeleteRequest\x1a\x11.crontab.Response\" \x82\xd3\xe4\x93\x02\x1a:\x01*\"\x15/plan/api/remove/{id}\x12x\n" +
+	"\x15ListRecordPlanStreams\x12\x1a.crontab.ReqPlanStreamList\x1a%.crontab.RecordPlanStreamResponseList\"\x1c\x82\xd3\xe4\x93\x02\x16\x12\x14/planstream/api/list\x12]\n" +
+	"\x13AddRecordPlanStream\x12\x13.crontab.PlanStream\x1a\x11.crontab.Response\"\x1e\x82\xd3\xe4\x93\x02\x18:\x01*\"\x13/planstream/api/add\x12c\n" +
+	"\x16UpdateRecordPlanStream\x12\x13.crontab.PlanStream\x1a\x11.crontab.Response\"!\x82\xd3\xe4\x93\x02\x1b:\x01*\"\x16/planstream/api/update\x12\x89\x01\n" +
+	"\x16RemoveRecordPlanStream\x12 .crontab.DeletePlanStreamRequest\x1a\x11.crontab.Response\":\x82\xd3\xe4\x93\x024:\x01*\"//planstream/api/remove/{planId}/{streamPath=**}\x12f\n" +
+	"\rParsePlanTime\x12\x19.crontab.ParsePlanRequest\x1a\x1a.crontab.ParsePlanResponse\"\x1e\x82\xd3\xe4\x93\x02\x18\x12\x16/plan/api/parse/{plan}\x12n\n" +
+	"\x10GetCrontabStatus\x12\x1d.crontab.CrontabStatusRequest\x1a\x1e.crontab.CrontabStatusResponse\"\x1b\x82\xd3\xe4\x93\x02\x15\x12\x13/crontab/api/statusB\x1fZ\x1dm7s.live/v5/plugin/crontab/pbb\x06proto3"
 
 var (
 	file_crontab_proto_rawDescOnce sync.Once
@@ -390,32 +1234,66 @@ func file_crontab_proto_rawDescGZIP() []byte {
 	return file_crontab_proto_rawDescData
 }
 
-var file_crontab_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
+var file_crontab_proto_msgTypes = make([]protoimpl.MessageInfo, 15)
 var file_crontab_proto_goTypes = []any{
-	(*PlanResponseList)(nil),      // 0: crontab.PlanResponseList
-	(*Plan)(nil),                  // 1: crontab.Plan
-	(*ReqPlanList)(nil),           // 2: crontab.ReqPlanList
-	(*DeleteRequest)(nil),         // 3: crontab.DeleteRequest
-	(*Response)(nil),              // 4: crontab.Response
-	(*timestamppb.Timestamp)(nil), // 5: google.protobuf.Timestamp
+	(*PlanResponseList)(nil),             // 0: crontab.PlanResponseList
+	(*Plan)(nil),                         // 1: crontab.Plan
+	(*ReqPlanList)(nil),                  // 2: crontab.ReqPlanList
+	(*DeleteRequest)(nil),                // 3: crontab.DeleteRequest
+	(*Response)(nil),                     // 4: crontab.Response
+	(*PlanStream)(nil),                   // 5: crontab.PlanStream
+	(*ReqPlanStreamList)(nil),            // 6: crontab.ReqPlanStreamList
+	(*RecordPlanStreamResponseList)(nil), // 7: crontab.RecordPlanStreamResponseList
+	(*DeletePlanStreamRequest)(nil),      // 8: crontab.DeletePlanStreamRequest
+	(*ParsePlanRequest)(nil),             // 9: crontab.ParsePlanRequest
+	(*TimeSlotInfo)(nil),                 // 10: crontab.TimeSlotInfo
+	(*ParsePlanResponse)(nil),            // 11: crontab.ParsePlanResponse
+	(*CrontabStatusRequest)(nil),         // 12: crontab.CrontabStatusRequest
+	(*CrontabTaskInfo)(nil),              // 13: crontab.CrontabTaskInfo
+	(*CrontabStatusResponse)(nil),        // 14: crontab.CrontabStatusResponse
+	(*timestamppb.Timestamp)(nil),        // 15: google.protobuf.Timestamp
 }
 var file_crontab_proto_depIdxs = []int32{
-	1, // 0: crontab.PlanResponseList.data:type_name -> crontab.Plan
-	5, // 1: crontab.Plan.createTime:type_name -> google.protobuf.Timestamp
-	5, // 2: crontab.Plan.updateTime:type_name -> google.protobuf.Timestamp
-	2, // 3: crontab.api.List:input_type -> crontab.ReqPlanList
-	1, // 4: crontab.api.Add:input_type -> crontab.Plan
-	1, // 5: crontab.api.Update:input_type -> crontab.Plan
-	3, // 6: crontab.api.Remove:input_type -> crontab.DeleteRequest
-	0, // 7: crontab.api.List:output_type -> crontab.PlanResponseList
-	4, // 8: crontab.api.Add:output_type -> crontab.Response
-	4, // 9: crontab.api.Update:output_type -> crontab.Response
-	4, // 10: crontab.api.Remove:output_type -> crontab.Response
-	7, // [7:11] is the sub-list for method output_type
-	3, // [3:7] is the sub-list for method input_type
-	3, // [3:3] is the sub-list for extension type_name
-	3, // [3:3] is the sub-list for extension extendee
-	0, // [0:3] is the sub-list for field type_name
+	1,  // 0: crontab.PlanResponseList.data:type_name -> crontab.Plan
+	15, // 1: crontab.Plan.createTime:type_name -> google.protobuf.Timestamp
+	15, // 2: crontab.Plan.updateTime:type_name -> google.protobuf.Timestamp
+	15, // 3: crontab.PlanStream.created_at:type_name -> google.protobuf.Timestamp
+	15, // 4: crontab.PlanStream.updated_at:type_name -> google.protobuf.Timestamp
+	5,  // 5: crontab.RecordPlanStreamResponseList.data:type_name -> crontab.PlanStream
+	15, // 6: crontab.TimeSlotInfo.start:type_name -> google.protobuf.Timestamp
+	15, // 7: crontab.TimeSlotInfo.end:type_name -> google.protobuf.Timestamp
+	10, // 8: crontab.ParsePlanResponse.slots:type_name -> crontab.TimeSlotInfo
+	10, // 9: crontab.ParsePlanResponse.next_slot:type_name -> crontab.TimeSlotInfo
+	15, // 10: crontab.CrontabTaskInfo.start_time:type_name -> google.protobuf.Timestamp
+	15, // 11: crontab.CrontabTaskInfo.end_time:type_name -> google.protobuf.Timestamp
+	10, // 12: crontab.CrontabTaskInfo.plan_slots:type_name -> crontab.TimeSlotInfo
+	13, // 13: crontab.CrontabStatusResponse.running_tasks:type_name -> crontab.CrontabTaskInfo
+	13, // 14: crontab.CrontabStatusResponse.next_tasks:type_name -> crontab.CrontabTaskInfo
+	2,  // 15: crontab.api.List:input_type -> crontab.ReqPlanList
+	1,  // 16: crontab.api.Add:input_type -> crontab.Plan
+	1,  // 17: crontab.api.Update:input_type -> crontab.Plan
+	3,  // 18: crontab.api.Remove:input_type -> crontab.DeleteRequest
+	6,  // 19: crontab.api.ListRecordPlanStreams:input_type -> crontab.ReqPlanStreamList
+	5,  // 20: crontab.api.AddRecordPlanStream:input_type -> crontab.PlanStream
+	5,  // 21: crontab.api.UpdateRecordPlanStream:input_type -> crontab.PlanStream
+	8,  // 22: crontab.api.RemoveRecordPlanStream:input_type -> crontab.DeletePlanStreamRequest
+	9,  // 23: crontab.api.ParsePlanTime:input_type -> crontab.ParsePlanRequest
+	12, // 24: crontab.api.GetCrontabStatus:input_type -> crontab.CrontabStatusRequest
+	0,  // 25: crontab.api.List:output_type -> crontab.PlanResponseList
+	4,  // 26: crontab.api.Add:output_type -> crontab.Response
+	4,  // 27: crontab.api.Update:output_type -> crontab.Response
+	4,  // 28: crontab.api.Remove:output_type -> crontab.Response
+	7,  // 29: crontab.api.ListRecordPlanStreams:output_type -> crontab.RecordPlanStreamResponseList
+	4,  // 30: crontab.api.AddRecordPlanStream:output_type -> crontab.Response
+	4,  // 31: crontab.api.UpdateRecordPlanStream:output_type -> crontab.Response
+	4,  // 32: crontab.api.RemoveRecordPlanStream:output_type -> crontab.Response
+	11, // 33: crontab.api.ParsePlanTime:output_type -> crontab.ParsePlanResponse
+	14, // 34: crontab.api.GetCrontabStatus:output_type -> crontab.CrontabStatusResponse
+	25, // [25:35] is the sub-list for method output_type
+	15, // [15:25] is the sub-list for method input_type
+	15, // [15:15] is the sub-list for extension type_name
+	15, // [15:15] is the sub-list for extension extendee
+	0,  // [0:15] is the sub-list for field type_name
 }
 
 func init() { file_crontab_proto_init() }
@@ -429,7 +1307,7 @@ func file_crontab_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: unsafe.Slice(unsafe.StringData(file_crontab_proto_rawDesc), len(file_crontab_proto_rawDesc)),
 			NumEnums:      0,
-			NumMessages:   5,
+			NumMessages:   15,
 			NumExtensions: 0,
 			NumServices:   1,
 		},

plugin/crontab/pb/crontab.pb.gw.go

@@ -176,6 +176,215 @@ func local_request_Api_Remove_0(ctx context.Context, marshaler runtime.Marshaler
 	return msg, metadata, err
 }
 
+var filter_Api_ListRecordPlanStreams_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+
+func request_Api_ListRecordPlanStreams_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq ReqPlanStreamList
+		metadata runtime.ServerMetadata
+	)
+	io.Copy(io.Discard, req.Body)
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_ListRecordPlanStreams_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	msg, err := client.ListRecordPlanStreams(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_Api_ListRecordPlanStreams_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq ReqPlanStreamList
+		metadata runtime.ServerMetadata
+	)
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_ListRecordPlanStreams_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	msg, err := server.ListRecordPlanStreams(ctx, &protoReq)
+	return msg, metadata, err
+}
+
+func request_Api_AddRecordPlanStream_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq PlanStream
+		metadata runtime.ServerMetadata
+	)
+	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	msg, err := client.AddRecordPlanStream(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_Api_AddRecordPlanStream_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq PlanStream
+		metadata runtime.ServerMetadata
+	)
+	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	msg, err := server.AddRecordPlanStream(ctx, &protoReq)
+	return msg, metadata, err
+}
+
+func request_Api_UpdateRecordPlanStream_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq PlanStream
+		metadata runtime.ServerMetadata
+	)
+	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	msg, err := client.UpdateRecordPlanStream(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_Api_UpdateRecordPlanStream_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq PlanStream
+		metadata runtime.ServerMetadata
+	)
+	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	msg, err := server.UpdateRecordPlanStream(ctx, &protoReq)
+	return msg, metadata, err
+}
+
+func request_Api_RemoveRecordPlanStream_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq DeletePlanStreamRequest
+		metadata runtime.ServerMetadata
+		err      error
+	)
+	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	val, ok := pathParams["planId"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "planId")
+	}
+	protoReq.PlanId, err = runtime.Uint32(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "planId", err)
+	}
+	val, ok = pathParams["streamPath"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "streamPath")
+	}
+	protoReq.StreamPath, err = runtime.String(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "streamPath", err)
+	}
+	msg, err := client.RemoveRecordPlanStream(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_Api_RemoveRecordPlanStream_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq DeletePlanStreamRequest
+		metadata runtime.ServerMetadata
+		err      error
+	)
+	if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	val, ok := pathParams["planId"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "planId")
+	}
+	protoReq.PlanId, err = runtime.Uint32(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "planId", err)
+	}
+	val, ok = pathParams["streamPath"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "streamPath")
+	}
+	protoReq.StreamPath, err = runtime.String(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "streamPath", err)
+	}
+	msg, err := server.RemoveRecordPlanStream(ctx, &protoReq)
+	return msg, metadata, err
+}
+
+func request_Api_ParsePlanTime_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq ParsePlanRequest
+		metadata runtime.ServerMetadata
+		err      error
+	)
+	io.Copy(io.Discard, req.Body)
+	val, ok := pathParams["plan"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "plan")
+	}
+	protoReq.Plan, err = runtime.String(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "plan", err)
+	}
+	msg, err := client.ParsePlanTime(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_Api_ParsePlanTime_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq ParsePlanRequest
+		metadata runtime.ServerMetadata
+		err      error
+	)
+	val, ok := pathParams["plan"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "plan")
+	}
+	protoReq.Plan, err = runtime.String(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "plan", err)
+	}
+	msg, err := server.ParsePlanTime(ctx, &protoReq)
+	return msg, metadata, err
+}
+
+var filter_Api_GetCrontabStatus_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+
+func request_Api_GetCrontabStatus_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq CrontabStatusRequest
+		metadata runtime.ServerMetadata
+	)
+	io.Copy(io.Discard, req.Body)
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetCrontabStatus_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	msg, err := client.GetCrontabStatus(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_Api_GetCrontabStatus_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq CrontabStatusRequest
+		metadata runtime.ServerMetadata
+	)
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetCrontabStatus_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	msg, err := server.GetCrontabStatus(ctx, &protoReq)
+	return msg, metadata, err
+}
+
 // RegisterApiHandlerServer registers the http handlers for service Api to "mux".
 // UnaryRPC     :call ApiServer directly.
 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
@@ -262,6 +471,126 @@ func RegisterApiHandlerServer(ctx context.Context, mux *runtime.ServeMux, server
 		}
 		forward_Api_Remove_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 	})
+	mux.Handle(http.MethodGet, pattern_Api_ListRecordPlanStreams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/crontab.Api/ListRecordPlanStreams", runtime.WithHTTPPathPattern("/planstream/api/list"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Api_ListRecordPlanStreams_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		forward_Api_ListRecordPlanStreams_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodPost, pattern_Api_AddRecordPlanStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/crontab.Api/AddRecordPlanStream", runtime.WithHTTPPathPattern("/planstream/api/add"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Api_AddRecordPlanStream_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		forward_Api_AddRecordPlanStream_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodPost, pattern_Api_UpdateRecordPlanStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/crontab.Api/UpdateRecordPlanStream", runtime.WithHTTPPathPattern("/planstream/api/update"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Api_UpdateRecordPlanStream_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		forward_Api_UpdateRecordPlanStream_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodPost, pattern_Api_RemoveRecordPlanStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/crontab.Api/RemoveRecordPlanStream", runtime.WithHTTPPathPattern("/planstream/api/remove/{planId}/{streamPath=**}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Api_RemoveRecordPlanStream_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		forward_Api_RemoveRecordPlanStream_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodGet, pattern_Api_ParsePlanTime_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/crontab.Api/ParsePlanTime", runtime.WithHTTPPathPattern("/plan/api/parse/{plan}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Api_ParsePlanTime_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		forward_Api_ParsePlanTime_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodGet, pattern_Api_GetCrontabStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/crontab.Api/GetCrontabStatus", runtime.WithHTTPPathPattern("/crontab/api/status"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Api_GetCrontabStatus_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		forward_Api_GetCrontabStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
 
 	return nil
 }
@@ -370,19 +699,133 @@ func RegisterApiHandlerClient(ctx context.Context, mux *runtime.ServeMux, client
 		}
 		forward_Api_Remove_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 	})
+	mux.Handle(http.MethodGet, pattern_Api_ListRecordPlanStreams_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/crontab.Api/ListRecordPlanStreams", runtime.WithHTTPPathPattern("/planstream/api/list"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Api_ListRecordPlanStreams_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		forward_Api_ListRecordPlanStreams_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodPost, pattern_Api_AddRecordPlanStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/crontab.Api/AddRecordPlanStream", runtime.WithHTTPPathPattern("/planstream/api/add"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Api_AddRecordPlanStream_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		forward_Api_AddRecordPlanStream_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodPost, pattern_Api_UpdateRecordPlanStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/crontab.Api/UpdateRecordPlanStream", runtime.WithHTTPPathPattern("/planstream/api/update"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Api_UpdateRecordPlanStream_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		forward_Api_UpdateRecordPlanStream_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodPost, pattern_Api_RemoveRecordPlanStream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/crontab.Api/RemoveRecordPlanStream", runtime.WithHTTPPathPattern("/planstream/api/remove/{planId}/{streamPath=**}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Api_RemoveRecordPlanStream_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		forward_Api_RemoveRecordPlanStream_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodGet, pattern_Api_ParsePlanTime_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/crontab.Api/ParsePlanTime", runtime.WithHTTPPathPattern("/plan/api/parse/{plan}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Api_ParsePlanTime_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		forward_Api_ParsePlanTime_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodGet, pattern_Api_GetCrontabStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/crontab.Api/GetCrontabStatus", runtime.WithHTTPPathPattern("/crontab/api/status"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Api_GetCrontabStatus_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		forward_Api_GetCrontabStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
 	return nil
 }
 
 var (
-	pattern_Api_List_0   = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"plan", "api", "list"}, ""))
-	pattern_Api_Add_0    = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"plan", "api", "add"}, ""))
-	pattern_Api_Update_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"plan", "api", "update", "id"}, ""))
-	pattern_Api_Remove_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"plan", "api", "remove", "id"}, ""))
+	pattern_Api_List_0                   = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"plan", "api", "list"}, ""))
+	pattern_Api_Add_0                    = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"plan", "api", "add"}, ""))
+	pattern_Api_Update_0                 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"plan", "api", "update", "id"}, ""))
+	pattern_Api_Remove_0                 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"plan", "api", "remove", "id"}, ""))
+	pattern_Api_ListRecordPlanStreams_0  = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"planstream", "api", "list"}, ""))
+	pattern_Api_AddRecordPlanStream_0    = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"planstream", "api", "add"}, ""))
+	pattern_Api_UpdateRecordPlanStream_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"planstream", "api", "update"}, ""))
+	pattern_Api_RemoveRecordPlanStream_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 3, 0, 4, 1, 5, 4}, []string{"planstream", "api", "remove", "planId", "streamPath"}, ""))
+	pattern_Api_ParsePlanTime_0          = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 0}, []string{"plan", "api", "parse"}, ""))
+	pattern_Api_GetCrontabStatus_0       = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"crontab", "api", "status"}, ""))
 )
 
 var (
-	forward_Api_List_0   = runtime.ForwardResponseMessage
-	forward_Api_Add_0    = runtime.ForwardResponseMessage
-	forward_Api_Update_0 = runtime.ForwardResponseMessage
-	forward_Api_Remove_0 = runtime.ForwardResponseMessage
+	forward_Api_List_0                   = runtime.ForwardResponseMessage
+	forward_Api_Add_0                    = runtime.ForwardResponseMessage
+	forward_Api_Update_0                 = runtime.ForwardResponseMessage
+	forward_Api_Remove_0                 = runtime.ForwardResponseMessage
+	forward_Api_ListRecordPlanStreams_0  = runtime.ForwardResponseMessage
+	forward_Api_AddRecordPlanStream_0    = runtime.ForwardResponseMessage
+	forward_Api_UpdateRecordPlanStream_0 = runtime.ForwardResponseMessage
+	forward_Api_RemoveRecordPlanStream_0 = runtime.ForwardResponseMessage
+	forward_Api_ParsePlanTime_0          = runtime.ForwardResponseMessage
+	forward_Api_GetCrontabStatus_0       = runtime.ForwardResponseMessage
 )

plugin/crontab/pb/crontab.proto

@@ -28,6 +28,45 @@ service api {
       body: "*"
     };
   }
+
+  // RecordPlanStream 相关接口
+  rpc ListRecordPlanStreams (ReqPlanStreamList) returns (RecordPlanStreamResponseList) {
+    option (google.api.http) = {
+      get: "/planstream/api/list"
+    };
+  }
+  rpc AddRecordPlanStream (PlanStream) returns (Response) {
+    option (google.api.http) = {
+      post: "/planstream/api/add"
+      body: "*"
+    };
+  }
+  rpc UpdateRecordPlanStream (PlanStream) returns (Response) {
+    option (google.api.http) = {
+      post: "/planstream/api/update"
+      body: "*"
+    };
+  }
+  rpc RemoveRecordPlanStream (DeletePlanStreamRequest) returns (Response) {
+    option (google.api.http) = {
+      post: "/planstream/api/remove/{planId}/{streamPath=**}"
+      body: "*"
+    };
+  }
+
+  // 解析计划字符串，返回时间段信息
+  rpc ParsePlanTime (ParsePlanRequest) returns (ParsePlanResponse) {
+    option (google.api.http) = {
+      get: "/plan/api/parse/{plan}"
+    };
+  }
+  
+  // 获取当前Crontab任务状态
+  rpc GetCrontabStatus (CrontabStatusRequest) returns (CrontabStatusResponse) {
+    option (google.api.http) = {
+      get: "/crontab/api/status"
+    };
+  }
 }
 
 message PlanResponseList {
@@ -60,4 +99,92 @@ message DeleteRequest {
 message Response {
   int32 code = 1;
   string message = 2;
+}
+
+// RecordPlanStream 相关消息定义
+message PlanStream {
+  uint32 planId = 1;
+  string stream_path = 2;
+  string fragment = 3;
+  string filePath = 4;
+  string record_type = 5; // 录制类型，例如 "mp4", "flv"
+  google.protobuf.Timestamp created_at = 6;
+  google.protobuf.Timestamp updated_at = 7;
+  bool enable = 8; // 是否启用该录制流
+}
+
+message ReqPlanStreamList {
+  uint32 pageNum = 1;
+  uint32 pageSize = 2;
+  uint32 planId = 3;  // 可选的按录制计划ID筛选
+  string stream_path = 4;     // 可选的按流路径筛选
+}
+
+message RecordPlanStreamResponseList {
+  int32 code = 1;
+  string message = 2;
+  uint32 totalCount = 3;
+  uint32 pageNum = 4;
+  uint32 pageSize = 5;
+  repeated PlanStream data = 6;
+}
+
+message DeletePlanStreamRequest {
+  uint32 planId = 1;
+  string streamPath = 2;
+}
+
+// 解析计划请求
+message ParsePlanRequest {
+  string plan = 1;  // 168位的0/1字符串，表示一周的每个小时是否录制
+}
+
+// 时间段信息
+message TimeSlotInfo {
+  google.protobuf.Timestamp start = 1;  // 开始时间
+  google.protobuf.Timestamp end = 2;    // 结束时间
+  string weekday = 3;                   // 周几（例如：周一）
+  string time_range = 4;                // 时间范围（例如：09:00-10:00）
+}
+
+// 解析计划响应
+message ParsePlanResponse {
+  int32 code = 1;                     // 响应码
+  string message = 2;                 // 响应消息
+  repeated TimeSlotInfo slots = 3;    // 所有计划的时间段
+  TimeSlotInfo next_slot = 4;        // 从当前时间开始的下一个时间段
+}
+
+// 新增的消息定义
+// 获取Crontab状态请求
+message CrontabStatusRequest {
+  // 可以为空，表示获取所有任务
+  string stream_path = 1; // 可选，按流路径过滤
+}
+
+// 任务信息
+message CrontabTaskInfo {
+  uint32 plan_id = 1;           // 计划ID
+  string plan_name = 2;         // 计划名称
+  string stream_path = 3;       // 流路径
+  bool is_recording = 4;        // 是否正在录制
+  google.protobuf.Timestamp start_time = 5;  // 当前/下一个任务开始时间
+  google.protobuf.Timestamp end_time = 6;    // 当前/下一个任务结束时间
+  string time_range = 7;        // 时间范围（例如：09:00-10:00）
+  string weekday = 8;           // 周几（例如：周一）
+  string file_path = 9;         // 文件保存路径
+  string fragment = 10;         // 分片设置
+  uint32 elapsed_seconds = 11;  // 已运行时间（秒，仅对正在运行的任务有效）
+  uint32 remaining_seconds = 12; // 剩余时间（秒）
+  repeated TimeSlotInfo plan_slots = 13; // 完整的计划时间段列表
+}
+
+// 获取Crontab状态响应
+message CrontabStatusResponse {
+  int32 code = 1;                      // 响应码
+  string message = 2;                  // 响应消息
+  repeated CrontabTaskInfo running_tasks = 3;  // 当前正在执行的任务列表
+  repeated CrontabTaskInfo next_tasks = 4;     // 下一个计划执行的任务列表
+  uint32 total_running = 5;            // 正在运行的任务总数
+  uint32 total_planned = 6;            // 计划中的任务总数
 }

plugin/crontab/pb/crontab_grpc.pb.go

@@ -19,10 +19,16 @@ import (
 const _ = grpc.SupportPackageIsVersion9
 
 const (
-	Api_List_FullMethodName   = "/crontab.api/List"
-	Api_Add_FullMethodName    = "/crontab.api/Add"
-	Api_Update_FullMethodName = "/crontab.api/Update"
-	Api_Remove_FullMethodName = "/crontab.api/Remove"
+	Api_List_FullMethodName                   = "/crontab.api/List"
+	Api_Add_FullMethodName                    = "/crontab.api/Add"
+	Api_Update_FullMethodName                 = "/crontab.api/Update"
+	Api_Remove_FullMethodName                 = "/crontab.api/Remove"
+	Api_ListRecordPlanStreams_FullMethodName  = "/crontab.api/ListRecordPlanStreams"
+	Api_AddRecordPlanStream_FullMethodName    = "/crontab.api/AddRecordPlanStream"
+	Api_UpdateRecordPlanStream_FullMethodName = "/crontab.api/UpdateRecordPlanStream"
+	Api_RemoveRecordPlanStream_FullMethodName = "/crontab.api/RemoveRecordPlanStream"
+	Api_ParsePlanTime_FullMethodName          = "/crontab.api/ParsePlanTime"
+	Api_GetCrontabStatus_FullMethodName       = "/crontab.api/GetCrontabStatus"
 )
 
 // ApiClient is the client API for Api service.
@@ -33,6 +39,15 @@ type ApiClient interface {
 	Add(ctx context.Context, in *Plan, opts ...grpc.CallOption) (*Response, error)
 	Update(ctx context.Context, in *Plan, opts ...grpc.CallOption) (*Response, error)
 	Remove(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*Response, error)
+	// RecordPlanStream 相关接口
+	ListRecordPlanStreams(ctx context.Context, in *ReqPlanStreamList, opts ...grpc.CallOption) (*RecordPlanStreamResponseList, error)
+	AddRecordPlanStream(ctx context.Context, in *PlanStream, opts ...grpc.CallOption) (*Response, error)
+	UpdateRecordPlanStream(ctx context.Context, in *PlanStream, opts ...grpc.CallOption) (*Response, error)
+	RemoveRecordPlanStream(ctx context.Context, in *DeletePlanStreamRequest, opts ...grpc.CallOption) (*Response, error)
+	// 解析计划字符串，返回时间段信息
+	ParsePlanTime(ctx context.Context, in *ParsePlanRequest, opts ...grpc.CallOption) (*ParsePlanResponse, error)
+	// 获取当前Crontab任务状态
+	GetCrontabStatus(ctx context.Context, in *CrontabStatusRequest, opts ...grpc.CallOption) (*CrontabStatusResponse, error)
 }
 
 type apiClient struct {
@@ -83,6 +98,66 @@ func (c *apiClient) Remove(ctx context.Context, in *DeleteRequest, opts ...grpc.
 	return out, nil
 }
 
+func (c *apiClient) ListRecordPlanStreams(ctx context.Context, in *ReqPlanStreamList, opts ...grpc.CallOption) (*RecordPlanStreamResponseList, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(RecordPlanStreamResponseList)
+	err := c.cc.Invoke(ctx, Api_ListRecordPlanStreams_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *apiClient) AddRecordPlanStream(ctx context.Context, in *PlanStream, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(Response)
+	err := c.cc.Invoke(ctx, Api_AddRecordPlanStream_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *apiClient) UpdateRecordPlanStream(ctx context.Context, in *PlanStream, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(Response)
+	err := c.cc.Invoke(ctx, Api_UpdateRecordPlanStream_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *apiClient) RemoveRecordPlanStream(ctx context.Context, in *DeletePlanStreamRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(Response)
+	err := c.cc.Invoke(ctx, Api_RemoveRecordPlanStream_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *apiClient) ParsePlanTime(ctx context.Context, in *ParsePlanRequest, opts ...grpc.CallOption) (*ParsePlanResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(ParsePlanResponse)
+	err := c.cc.Invoke(ctx, Api_ParsePlanTime_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *apiClient) GetCrontabStatus(ctx context.Context, in *CrontabStatusRequest, opts ...grpc.CallOption) (*CrontabStatusResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(CrontabStatusResponse)
+	err := c.cc.Invoke(ctx, Api_GetCrontabStatus_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // ApiServer is the server API for Api service.
 // All implementations must embed UnimplementedApiServer
 // for forward compatibility.
@@ -91,6 +166,15 @@ type ApiServer interface {
 	Add(context.Context, *Plan) (*Response, error)
 	Update(context.Context, *Plan) (*Response, error)
 	Remove(context.Context, *DeleteRequest) (*Response, error)
+	// RecordPlanStream 相关接口
+	ListRecordPlanStreams(context.Context, *ReqPlanStreamList) (*RecordPlanStreamResponseList, error)
+	AddRecordPlanStream(context.Context, *PlanStream) (*Response, error)
+	UpdateRecordPlanStream(context.Context, *PlanStream) (*Response, error)
+	RemoveRecordPlanStream(context.Context, *DeletePlanStreamRequest) (*Response, error)
+	// 解析计划字符串，返回时间段信息
+	ParsePlanTime(context.Context, *ParsePlanRequest) (*ParsePlanResponse, error)
+	// 获取当前Crontab任务状态
+	GetCrontabStatus(context.Context, *CrontabStatusRequest) (*CrontabStatusResponse, error)
 	mustEmbedUnimplementedApiServer()
 }
 
@@ -113,6 +197,24 @@ func (UnimplementedApiServer) Update(context.Context, *Plan) (*Response, error)
 func (UnimplementedApiServer) Remove(context.Context, *DeleteRequest) (*Response, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Remove not implemented")
 }
+func (UnimplementedApiServer) ListRecordPlanStreams(context.Context, *ReqPlanStreamList) (*RecordPlanStreamResponseList, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ListRecordPlanStreams not implemented")
+}
+func (UnimplementedApiServer) AddRecordPlanStream(context.Context, *PlanStream) (*Response, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method AddRecordPlanStream not implemented")
+}
+func (UnimplementedApiServer) UpdateRecordPlanStream(context.Context, *PlanStream) (*Response, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method UpdateRecordPlanStream not implemented")
+}
+func (UnimplementedApiServer) RemoveRecordPlanStream(context.Context, *DeletePlanStreamRequest) (*Response, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method RemoveRecordPlanStream not implemented")
+}
+func (UnimplementedApiServer) ParsePlanTime(context.Context, *ParsePlanRequest) (*ParsePlanResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ParsePlanTime not implemented")
+}
+func (UnimplementedApiServer) GetCrontabStatus(context.Context, *CrontabStatusRequest) (*CrontabStatusResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetCrontabStatus not implemented")
+}
 func (UnimplementedApiServer) mustEmbedUnimplementedApiServer() {}
 func (UnimplementedApiServer) testEmbeddedByValue()             {}
 
@@ -206,6 +308,114 @@ func _Api_Remove_Handler(srv interface{}, ctx context.Context, dec func(interfac
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Api_ListRecordPlanStreams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ReqPlanStreamList)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ApiServer).ListRecordPlanStreams(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Api_ListRecordPlanStreams_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ApiServer).ListRecordPlanStreams(ctx, req.(*ReqPlanStreamList))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Api_AddRecordPlanStream_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(PlanStream)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ApiServer).AddRecordPlanStream(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Api_AddRecordPlanStream_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ApiServer).AddRecordPlanStream(ctx, req.(*PlanStream))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Api_UpdateRecordPlanStream_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(PlanStream)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ApiServer).UpdateRecordPlanStream(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Api_UpdateRecordPlanStream_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ApiServer).UpdateRecordPlanStream(ctx, req.(*PlanStream))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Api_RemoveRecordPlanStream_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DeletePlanStreamRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ApiServer).RemoveRecordPlanStream(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Api_RemoveRecordPlanStream_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ApiServer).RemoveRecordPlanStream(ctx, req.(*DeletePlanStreamRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Api_ParsePlanTime_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ParsePlanRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ApiServer).ParsePlanTime(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Api_ParsePlanTime_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ApiServer).ParsePlanTime(ctx, req.(*ParsePlanRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Api_GetCrontabStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CrontabStatusRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ApiServer).GetCrontabStatus(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Api_GetCrontabStatus_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ApiServer).GetCrontabStatus(ctx, req.(*CrontabStatusRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 // Api_ServiceDesc is the grpc.ServiceDesc for Api service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@@ -229,6 +439,30 @@ var Api_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "Remove",
 			Handler:    _Api_Remove_Handler,
 		},
+		{
+			MethodName: "ListRecordPlanStreams",
+			Handler:    _Api_ListRecordPlanStreams_Handler,
+		},
+		{
+			MethodName: "AddRecordPlanStream",
+			Handler:    _Api_AddRecordPlanStream_Handler,
+		},
+		{
+			MethodName: "UpdateRecordPlanStream",
+			Handler:    _Api_UpdateRecordPlanStream_Handler,
+		},
+		{
+			MethodName: "RemoveRecordPlanStream",
+			Handler:    _Api_RemoveRecordPlanStream_Handler,
+		},
+		{
+			MethodName: "ParsePlanTime",
+			Handler:    _Api_ParsePlanTime_Handler,
+		},
+		{
+			MethodName: "GetCrontabStatus",
+			Handler:    _Api_GetCrontabStatus_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "crontab.proto",

plugin/crontab/pkg/plan.go

@@ -1,13 +0,0 @@
-package pkg
-
-import (
-	"gorm.io/gorm"
-)
-
-// RecordPlan 录制计划模型
-type RecordPlan struct {
-	gorm.Model
-	Name    string `json:"name" gorm:"default:''"`
-	Plan    string `json:"plan" gorm:"type:text"`
-	Enabled bool   `json:"enabled" gorm:"default:true"`
-}

plugin/crontab/pkg/recordplan.go

@@ -0,0 +1,17 @@
+package pkg
+
+import (
+	"gorm.io/gorm"
+)
+
+// RecordPlan 录制计划模型
+type RecordPlan struct {
+	gorm.Model
+	Name   string `json:"name" gorm:"default:''"`
+	Plan   string `json:"plan" gorm:"type:text"`
+	Enable bool   `json:"enable" gorm:"default:false"` // 是否启用
+}
+
+func (r *RecordPlan) GetKey() uint {
+	return r.ID
+}

plugin/crontab/pkg/recordplanstream.go

@@ -0,0 +1,51 @@
+package pkg
+
+import (
+	"gorm.io/gorm"
+	"time"
+)
+
+// RecordPlanStream 录制计划流信息模型
+type RecordPlanStream struct {
+	PlanID     uint   `json:"plan_id" gorm:"primaryKey;type:bigint;not null"` // 录制计划ID
+	StreamPath string `json:"stream_path" gorm:"primaryKey;type:varchar(255)"`
+	Fragment   string `json:"fragment" gorm:"type:text"`
+	FilePath   string `json:"file_path" gorm:"type:varchar(255)"`
+	CreatedAt  time.Time
+	UpdatedAt  time.Time
+	DeletedAt  gorm.DeletedAt `gorm:"index"`
+	Enable     bool           `json:"enable" gorm:"default:false"` // 是否启用
+	RecordType string         `json:"record_type" gorm:"type:varchar(255)"`
+}
+
+// TableName 设置表名
+func (RecordPlanStream) TableName() string {
+	return "record_plans_streams"
+}
+
+// ScopeStreamPathLike 模糊查询 StreamPath
+func ScopeStreamPathLike(streamPath string) func(db *gorm.DB) *gorm.DB {
+	return func(db *gorm.DB) *gorm.DB {
+		if streamPath != "" {
+			return db.Where("record_plans_streams.stream_path LIKE ?", "%"+streamPath+"%")
+		}
+		return db
+	}
+}
+
+// ScopeOrderByCreatedAtDesc 按创建时间倒序
+func ScopeOrderByCreatedAtDesc() func(db *gorm.DB) *gorm.DB {
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Order("record_plans_streams.created_at DESC")
+	}
+}
+
+// ScopeRecordPlanID 按录制计划ID查询
+func ScopeRecordPlanID(recordPlanID uint) func(db *gorm.DB) *gorm.DB {
+	return func(db *gorm.DB) *gorm.DB {
+		if recordPlanID > 0 {
+			return db.Where(&RecordPlanStream{PlanID: recordPlanID})
+		}
+		return db
+	}
+}

plugin/debug/chart.go

@@ -15,6 +15,7 @@ import (
 	"github.com/gorilla/websocket"
 	"github.com/shirou/gopsutil/v4/cpu"
 	"github.com/shirou/gopsutil/v4/process"
+	"m7s.live/v5/pkg/task"
 )
 
 //go:embed static/*
@@ -40,8 +41,17 @@ type consumer struct {
 }
 
 type server struct {
+	task.TickTask
 	consumers      []consumer
 	consumersMutex sync.RWMutex
+	data           DataStorage
+	lastPause      uint32
+	dataMutex      sync.RWMutex
+	lastConsumerID uint
+	upgrader       websocket.Upgrader
+	prevSysTime    float64
+	prevUserTime   float64
+	myProcess      *process.Process
 }
 
 type SimplePair struct {
@@ -75,99 +85,91 @@ const (
 	maxCount int = 86400
 )
 
-var (
-	data           DataStorage
-	lastPause      uint32
-	mutex          sync.RWMutex
-	lastConsumerID uint
-	s              server
-	upgrader       = websocket.Upgrader{
+func (s *server) Start() error {
+	var err error
+	s.myProcess, err = process.NewProcess(int32(os.Getpid()))
+	if err != nil {
+		log.Printf("Failed to get process: %v", err)
+	}
+	// 初始化 WebSocket upgrader
+	s.upgrader = websocket.Upgrader{
 		ReadBufferSize:  1024,
 		WriteBufferSize: 1024,
 	}
-	prevSysTime  float64
-	prevUserTime float64
-	myProcess    *process.Process
-)
-
-func init() {
-
-	myProcess, _ = process.NewProcess(int32(os.Getpid()))
-
 	// preallocate arrays in data, helps save on reallocations caused by append()
 	// when maxCount is large
-	data.BytesAllocated = make([]SimplePair, 0, maxCount)
-	data.GcPauses = make([]SimplePair, 0, maxCount)
-	data.CPUUsage = make([]CPUPair, 0, maxCount)
-	data.Pprof = make([]PprofPair, 0, maxCount)
-
-	go s.gatherData()
+	s.data.BytesAllocated = make([]SimplePair, 0, maxCount)
+	s.data.GcPauses = make([]SimplePair, 0, maxCount)
+	s.data.CPUUsage = make([]CPUPair, 0, maxCount)
+	s.data.Pprof = make([]PprofPair, 0, maxCount)
+	return s.TickTask.Start()
 }
 
-func (s *server) gatherData() {
-	timer := time.Tick(time.Second)
+func (s *server) GetTickInterval() time.Duration {
+	return time.Second
+}
 
-	for now := range timer {
-		nowUnix := now.Unix()
+func (s *server) Tick(any) {
+	now := time.Now()
+	nowUnix := now.Unix()
 
-		var ms runtime.MemStats
-		runtime.ReadMemStats(&ms)
+	var ms runtime.MemStats
+	runtime.ReadMemStats(&ms)
 
-		u := update{
-			Ts:           nowUnix * 1000,
-			Block:        pprof.Lookup("block").Count(),
-			Goroutine:    pprof.Lookup("goroutine").Count(),
-			Heap:         pprof.Lookup("heap").Count(),
-			Mutex:        pprof.Lookup("mutex").Count(),
-			Threadcreate: pprof.Lookup("threadcreate").Count(),
-		}
-		data.Pprof = append(data.Pprof, PprofPair{
-			uint64(nowUnix) * 1000,
-			u.Block,
-			u.Goroutine,
-			u.Heap,
-			u.Mutex,
-			u.Threadcreate,
-		})
-
-		cpuTimes, err := myProcess.Times()
-		if err != nil {
-			cpuTimes = &cpu.TimesStat{}
-		}
-
-		if prevUserTime != 0 {
-			u.CPUUser = cpuTimes.User - prevUserTime
-			u.CPUSys = cpuTimes.System - prevSysTime
-			data.CPUUsage = append(data.CPUUsage, CPUPair{uint64(nowUnix) * 1000, u.CPUUser, u.CPUSys})
-		}
-
-		prevUserTime = cpuTimes.User
-		prevSysTime = cpuTimes.System
-
-		mutex.Lock()
-
-		bytesAllocated := ms.Alloc
-		u.BytesAllocated = bytesAllocated
-		data.BytesAllocated = append(data.BytesAllocated, SimplePair{uint64(nowUnix) * 1000, bytesAllocated})
-		if lastPause == 0 || lastPause != ms.NumGC {
-			gcPause := ms.PauseNs[(ms.NumGC+255)%256]
-			u.GcPause = gcPause
-			data.GcPauses = append(data.GcPauses, SimplePair{uint64(nowUnix) * 1000, gcPause})
-			lastPause = ms.NumGC
-		}
-
-		if len(data.BytesAllocated) > maxCount {
-			data.BytesAllocated = data.BytesAllocated[len(data.BytesAllocated)-maxCount:]
-		}
-
-		if len(data.GcPauses) > maxCount {
-			data.GcPauses = data.GcPauses[len(data.GcPauses)-maxCount:]
-		}
-
-		mutex.Unlock()
-
-		s.sendToConsumers(u)
+	u := update{
+		Ts:           nowUnix * 1000,
+		Block:        pprof.Lookup("block").Count(),
+		Goroutine:    pprof.Lookup("goroutine").Count(),
+		Heap:         pprof.Lookup("heap").Count(),
+		Mutex:        pprof.Lookup("mutex").Count(),
+		Threadcreate: pprof.Lookup("threadcreate").Count(),
 	}
+	s.data.Pprof = append(s.data.Pprof, PprofPair{
+		uint64(nowUnix) * 1000,
+		u.Block,
+		u.Goroutine,
+		u.Heap,
+		u.Mutex,
+		u.Threadcreate,
+	})
+
+	cpuTimes, err := s.myProcess.Times()
+	if err != nil {
+		cpuTimes = &cpu.TimesStat{}
+	}
+
+	if s.prevUserTime != 0 {
+		u.CPUUser = cpuTimes.User - s.prevUserTime
+		u.CPUSys = cpuTimes.System - s.prevSysTime
+		s.data.CPUUsage = append(s.data.CPUUsage, CPUPair{uint64(nowUnix) * 1000, u.CPUUser, u.CPUSys})
+	}
+
+	s.prevUserTime = cpuTimes.User
+	s.prevSysTime = cpuTimes.System
+
+	s.dataMutex.Lock()
+
+	bytesAllocated := ms.Alloc
+	u.BytesAllocated = bytesAllocated
+	s.data.BytesAllocated = append(s.data.BytesAllocated, SimplePair{uint64(nowUnix) * 1000, bytesAllocated})
+	if s.lastPause == 0 || s.lastPause != ms.NumGC {
+		gcPause := ms.PauseNs[(ms.NumGC+255)%256]
+		u.GcPause = gcPause
+		s.data.GcPauses = append(s.data.GcPauses, SimplePair{uint64(nowUnix) * 1000, gcPause})
+		s.lastPause = ms.NumGC
+	}
+
+	if len(s.data.BytesAllocated) > maxCount {
+		s.data.BytesAllocated = s.data.BytesAllocated[len(s.data.BytesAllocated)-maxCount:]
+	}
+
+	if len(s.data.GcPauses) > maxCount {
+		s.data.GcPauses = s.data.GcPauses[len(s.data.GcPauses)-maxCount:]
+	}
+
+	s.dataMutex.Unlock()
+
+	s.sendToConsumers(u)
 }
 
 func (s *server) sendToConsumers(u update) {
@@ -203,10 +205,10 @@ func (s *server) addConsumer() consumer {
 	s.consumersMutex.Lock()
 	defer s.consumersMutex.Unlock()
 
-	lastConsumerID++
+	s.lastConsumerID++
 
 	c := consumer{
-		id: lastConsumerID,
+		id: s.lastConsumerID,
 		c:  make(chan update),
 	}
 
@@ -221,7 +223,7 @@ func (s *server) dataFeedHandler(w http.ResponseWriter, r *http.Request) {
 		lastPong time.Time
 	)
 
-	conn, err := upgrader.Upgrade(w, r, nil)
+	conn, err := s.upgrader.Upgrade(w, r, nil)
 	if err != nil {
 		log.Println(err)
 		return
@@ -268,9 +270,9 @@ func (s *server) dataFeedHandler(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func dataHandler(w http.ResponseWriter, r *http.Request) {
-	mutex.RLock()
-	defer mutex.RUnlock()
+func (s *server) dataHandler(w http.ResponseWriter, r *http.Request) {
+	s.dataMutex.RLock()
+	defer s.dataMutex.RUnlock()
 
 	if e := r.ParseForm(); e != nil {
 		log.Print("error parsing form")
@@ -284,7 +286,7 @@ func dataHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
 	encoder := json.NewEncoder(w)
-	encoder.Encode(data)
+	encoder.Encode(s.data)
 
 	fmt.Fprint(w, ")")
 }

plugin/debug/envcheck.go

@@ -0,0 +1,219 @@
+package plugin_debug
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"time"
+
+	"google.golang.org/protobuf/types/known/timestamppb"
+	"gopkg.in/yaml.v3"
+	"m7s.live/v5/pb"
+	"m7s.live/v5/pkg/util"
+)
+
+type EnvCheckResult struct {
+	Message string `json:"message"`
+	Type    string `json:"type"` // info, success, error, complete
+}
+
+// 自定义系统信息响应结构体，用于 JSON 解析
+type SysInfoResponseJSON struct {
+	Code    int32  `json:"code"`
+	Message string `json:"message"`
+	Data    struct {
+		StartTime string `json:"startTime"`
+		LocalIP   string `json:"localIP"`
+		PublicIP  string `json:"publicIP"`
+		Version   string `json:"version"`
+		GoVersion string `json:"goVersion"`
+		OS        string `json:"os"`
+		Arch      string `json:"arch"`
+		CPUs      int32  `json:"cpus"`
+		Plugins   []struct {
+			Name        string            `json:"name"`
+			PushAddr    []string          `json:"pushAddr"`
+			PlayAddr    []string          `json:"playAddr"`
+			Description map[string]string `json:"description"`
+		} `json:"plugins"`
+	} `json:"data"`
+}
+
+// 插件配置响应结构体
+type PluginConfigResponse struct {
+	Code    int32  `json:"code"`
+	Message string `json:"message"`
+	Data    struct {
+		File     string `json:"file"`
+		Modified string `json:"modified"`
+		Merged   string `json:"merged"`
+	} `json:"data"`
+}
+
+// TCP 配置结构体
+type TCPConfig struct {
+	ListenAddr    string `yaml:"listenaddr"`
+	ListenAddrTLS string `yaml:"listenaddrtls"`
+}
+
+// 插件配置结构体
+type PluginConfig struct {
+	TCP TCPConfig `yaml:"tcp"`
+}
+
+func (p *DebugPlugin) EnvCheck(w http.ResponseWriter, r *http.Request) {
+	// Get target URL from query parameter
+	targetURL := r.URL.Query().Get("target")
+	if targetURL == "" {
+		r.URL.Path = "/static/envcheck.html"
+		staticFSHandler.ServeHTTP(w, r)
+		return
+	}
+
+	// Create SSE connection
+	util.NewSSE(w, r.Context(), func(sse *util.SSE) {
+		// Function to send SSE messages
+		sendMessage := func(message string, msgType string) {
+			result := EnvCheckResult{
+				Message: message,
+				Type:    msgType,
+			}
+			sse.WriteJSON(result)
+		}
+
+		// Parse target URL
+		_, err := url.Parse(targetURL)
+		if err != nil {
+			sendMessage(fmt.Sprintf("Invalid URL: %v", err), "error")
+			return
+		}
+
+		// Check if we can connect to the target server
+		sendMessage(fmt.Sprintf("Checking connection to %s...", targetURL), "info")
+
+		// Get system info from target server
+		resp, err := http.Get(fmt.Sprintf("%s/api/sysinfo", targetURL))
+		if err != nil {
+			sendMessage(fmt.Sprintf("Failed to connect to target server: %v", err), "error")
+			return
+		}
+		defer resp.Body.Close()
+
+		if resp.StatusCode != http.StatusOK {
+			sendMessage(fmt.Sprintf("Target server returned status code: %d", resp.StatusCode), "error")
+			return
+		}
+
+		// Read and parse system info
+		body, err := io.ReadAll(resp.Body)
+		if err != nil {
+			sendMessage(fmt.Sprintf("Failed to read response: %v", err), "error")
+			return
+		}
+
+		var sysInfoJSON SysInfoResponseJSON
+		if err := json.Unmarshal(body, &sysInfoJSON); err != nil {
+			sendMessage(fmt.Sprintf("Failed to parse system info: %v", err), "error")
+			return
+		}
+
+		// Convert JSON response to protobuf response
+		sysInfo := &pb.SysInfoResponse{
+			Code:    sysInfoJSON.Code,
+			Message: sysInfoJSON.Message,
+			Data: &pb.SysInfoData{
+				LocalIP:   sysInfoJSON.Data.LocalIP,
+				PublicIP:  sysInfoJSON.Data.PublicIP,
+				Version:   sysInfoJSON.Data.Version,
+				GoVersion: sysInfoJSON.Data.GoVersion,
+				Os:        sysInfoJSON.Data.OS,
+				Arch:      sysInfoJSON.Data.Arch,
+				Cpus:      sysInfoJSON.Data.CPUs,
+			},
+		}
+
+		// Parse start time
+		if startTime, err := time.Parse(time.RFC3339, sysInfoJSON.Data.StartTime); err == nil {
+			sysInfo.Data.StartTime = timestamppb.New(startTime)
+		}
+
+		// Convert plugins
+		for _, pluginJSON := range sysInfoJSON.Data.Plugins {
+			plugin := &pb.PluginInfo{
+				Name:        pluginJSON.Name,
+				PushAddr:    pluginJSON.PushAddr,
+				PlayAddr:    pluginJSON.PlayAddr,
+				Description: pluginJSON.Description,
+			}
+			sysInfo.Data.Plugins = append(sysInfo.Data.Plugins, plugin)
+		}
+
+		// Check each plugin's configuration
+		for _, plugin := range sysInfo.Data.Plugins {
+			// Get plugin configuration
+			configResp, err := http.Get(fmt.Sprintf("%s/api/config/get/%s", targetURL, plugin.Name))
+			if err != nil {
+				sendMessage(fmt.Sprintf("Failed to get configuration for plugin %s: %v", plugin.Name, err), "error")
+				continue
+			}
+			defer configResp.Body.Close()
+
+			if configResp.StatusCode != http.StatusOK {
+				sendMessage(fmt.Sprintf("Failed to get configuration for plugin %s: status code %d", plugin.Name, configResp.StatusCode), "error")
+				continue
+			}
+
+			var configRespJSON PluginConfigResponse
+			if err := json.NewDecoder(configResp.Body).Decode(&configRespJSON); err != nil {
+				sendMessage(fmt.Sprintf("Failed to parse configuration for plugin %s: %v", plugin.Name, err), "error")
+				continue
+			}
+
+			// Parse YAML configuration
+			var config PluginConfig
+			if err := yaml.Unmarshal([]byte(configRespJSON.Data.Merged), &config); err != nil {
+				sendMessage(fmt.Sprintf("Failed to parse YAML configuration for plugin %s: %v", plugin.Name, err), "error")
+				continue
+			}
+			// Check TCP configuration
+			if config.TCP.ListenAddr != "" {
+				host, port, err := net.SplitHostPort(config.TCP.ListenAddr)
+				if err != nil {
+					sendMessage(fmt.Sprintf("Invalid listenaddr format for plugin %s: %v", plugin.Name, err), "error")
+				} else {
+					sendMessage(fmt.Sprintf("Checking TCP listenaddr %s for plugin %s...", config.TCP.ListenAddr, plugin.Name), "info")
+					// Try to establish TCP connection
+					conn, err := net.DialTimeout("tcp", fmt.Sprintf("%s:%s", host, port), 5*time.Second)
+					if err != nil {
+						sendMessage(fmt.Sprintf("TCP listenaddr %s for plugin %s is not accessible: %v", config.TCP.ListenAddr, plugin.Name, err), "error")
+					} else {
+						conn.Close()
+						sendMessage(fmt.Sprintf("TCP listenaddr %s for plugin %s is accessible", config.TCP.ListenAddr, plugin.Name), "success")
+					}
+				}
+			}
+
+			if config.TCP.ListenAddrTLS != "" {
+				host, port, err := net.SplitHostPort(config.TCP.ListenAddrTLS)
+				if err != nil {
+					sendMessage(fmt.Sprintf("Invalid listenaddrtls format for plugin %s: %v", plugin.Name, err), "error")
+				} else {
+					sendMessage(fmt.Sprintf("Checking TCP TLS listenaddr %s for plugin %s...", config.TCP.ListenAddrTLS, plugin.Name), "info")
+					// Try to establish TCP connection
+					conn, err := net.DialTimeout("tcp", fmt.Sprintf("%s:%s", host, port), 5*time.Second)
+					if err != nil {
+						sendMessage(fmt.Sprintf("TCP TLS listenaddr %s for plugin %s is not accessible: %v", config.TCP.ListenAddrTLS, plugin.Name, err), "error")
+					} else {
+						conn.Close()
+						sendMessage(fmt.Sprintf("TCP TLS listenaddr %s for plugin %s is accessible", config.TCP.ListenAddrTLS, plugin.Name), "success")
+					}
+				}
+			}
+		}
+
+		sendMessage("Environment check completed", "complete")
+	})
+}

plugin/debug/index.go

@@ -34,13 +34,13 @@ type DebugPlugin struct {
 	m7s.Plugin
 	ProfileDuration time.Duration `default:"10s" desc:"profile持续时间"`
 	Profile         string        `desc:"采集profile存储文件"`
-	ChartPeriod     time.Duration `default:"1s" desc:"图表更新周期"`
 	Grfout          string        `default:"grf.out" desc:"grf输出文件"`
-
+	EnableChart     bool          `default:"true" desc:"是否启用图表功能"`
 	// 添加缓存字段
 	cpuProfileData *profile.Profile // 缓存 CPU Profile 数据
 	cpuProfileOnce sync.Once        // 确保只采集一次
 	cpuProfileLock sync.Mutex       // 保护缓存数据
+	chartServer    server
 }
 
 type WriteToFile struct {
@@ -72,6 +72,10 @@ func (p *DebugPlugin) OnInit() error {
 			p.Info("cpu profile done")
 		}()
 	}
+	if p.EnableChart {
+		p.AddTask(&p.chartServer)
+	}
+
 	return nil
 }
 
@@ -100,11 +104,11 @@ func (p *DebugPlugin) Charts_(w http.ResponseWriter, r *http.Request) {
 }
 
 func (p *DebugPlugin) Charts_data(w http.ResponseWriter, r *http.Request) {
-	dataHandler(w, r)
+	p.chartServer.dataHandler(w, r)
 }
 
 func (p *DebugPlugin) Charts_datafeed(w http.ResponseWriter, r *http.Request) {
-	s.dataFeedHandler(w, r)
+	p.chartServer.dataFeedHandler(w, r)
 }
 
 func (p *DebugPlugin) Grf(w http.ResponseWriter, r *http.Request) {

plugin/debug/static/envcheck.html

@@ -0,0 +1,122 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Environment Check</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            margin: 20px;
+            background-color: #f5f5f5;
+        }
+
+        .container {
+            max-width: 800px;
+            margin: 0 auto;
+            background-color: white;
+            padding: 20px;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+        }
+
+        .input-group {
+            margin-bottom: 20px;
+        }
+
+        input[type="text"] {
+            padding: 8px;
+            width: 300px;
+            margin-right: 10px;
+        }
+
+        button {
+            padding: 8px 16px;
+            background-color: #4CAF50;
+            color: white;
+            border: none;
+            border-radius: 4px;
+            cursor: pointer;
+        }
+
+        button:hover {
+            background-color: #45a049;
+        }
+
+        #log {
+            background-color: #f8f9fa;
+            border: 1px solid #ddd;
+            padding: 10px;
+            height: 400px;
+            overflow-y: auto;
+            font-family: monospace;
+            white-space: pre-wrap;
+        }
+
+        .success {
+            color: #28a745;
+        }
+
+        .error {
+            color: #dc3545;
+        }
+
+        .info {
+            color: #17a2b8;
+        }
+    </style>
+</head>
+
+<body>
+    <div class="container">
+        <h1>Environment Check</h1>
+        <div class="input-group">
+            <input type="text" id="targetUrl" placeholder="Enter target URL (e.g., http://192.168.1.100:8080)">
+            <button onclick="startCheck()">Start Check</button>
+        </div>
+        <div id="log"></div>
+    </div>
+
+    <script>
+        function appendLog(message, type = 'info') {
+            const log = document.getElementById('log');
+            const entry = document.createElement('div');
+            entry.className = type;
+            entry.textContent = message;
+            log.appendChild(entry);
+            log.scrollTop = log.scrollHeight;
+        }
+
+        function startCheck() {
+            const targetUrl = document.getElementById('targetUrl').value;
+            if (!targetUrl) {
+                appendLog('Please enter a target URL', 'error');
+                return;
+            }
+
+            // Clear previous log
+            document.getElementById('log').innerHTML = '';
+            appendLog('Starting environment check...');
+
+            // Create SSE connection
+            const eventSource = new EventSource(`/debug/envcheck?target=${encodeURIComponent(targetUrl)}`);
+
+            eventSource.onmessage = function (event) {
+                const data = JSON.parse(event.data);
+                appendLog(data.message, data.type);
+
+                if (data.type === 'complete') {
+                    eventSource.close();
+                }
+            };
+
+            eventSource.onerror = function (error) {
+                appendLog('Connection error occurred', 'error');
+                eventSource.close();
+            };
+        }
+    </script>
+</body>
+
+</html>

plugin/flv/api.go

@@ -9,7 +9,7 @@ import (
 	flvpb "m7s.live/v5/plugin/flv/pb"
 )
 
-func (p *FLVPlugin) List(ctx context.Context, req *flvpb.ReqRecordList) (resp *pb.ResponseList, err error) {
+func (p *FLVPlugin) List(ctx context.Context, req *flvpb.ReqRecordList) (resp *pb.RecordResponseList, err error) {
 	globalReq := &pb.ReqRecordList{
 		StreamPath: req.StreamPath,
 		Range:      req.Range,
@@ -17,7 +17,6 @@ func (p *FLVPlugin) List(ctx context.Context, req *flvpb.ReqRecordList) (resp *p
 		End:        req.End,
 		PageNum:    req.PageNum,
 		PageSize:   req.PageSize,
-		Mode:       req.Mode,
 		Type:       "flv",
 	}
 	return p.Server.GetRecordList(ctx, globalReq)

plugin/flv/download.go

@@ -12,11 +12,9 @@ import (
 	"time"
 
 	m7s "m7s.live/v5"
-	codec "m7s.live/v5/pkg/codec"
 	"m7s.live/v5/pkg/util"
 	flv "m7s.live/v5/plugin/flv/pkg"
 	mp4 "m7s.live/v5/plugin/mp4/pkg"
-	"m7s.live/v5/plugin/mp4/pkg/box"
 	rtmp "m7s.live/v5/plugin/rtmp/pkg"
 )
 
@@ -198,31 +196,51 @@ func (plugin *FLVPlugin) processMp4ToFlv(w http.ResponseWriter, r *http.Request,
 		})
 	}
 
-	// 创建DemuxerRange进行MP4解复用
-	demuxer := &mp4.DemuxerRange{
-		StartTime: params.startTime,
-		EndTime:   params.endTime,
-		Streams:   mp4Streams,
+	// 创建DemuxerConverterRange进行MP4解复用和转换
+	demuxer := &mp4.DemuxerConverterRange[*rtmp.RTMPAudio, *rtmp.RTMPVideo]{
+		DemuxerRange: mp4.DemuxerRange{
+			StartTime: params.startTime,
+			EndTime:   params.endTime,
+			Streams:   mp4Streams,
+			Logger:    plugin.Logger.With("demuxer", "mp4_flv"),
+		},
 	}
 
 	// 创建FLV编码器状态
-	flvWriter := &flvMp4Writer{
-		FlvWriter:  flv.NewFlvWriter(w),
-		plugin:     plugin,
-		hasWritten: false,
-	}
-
-	// 设置回调函数
-	demuxer.OnVideoExtraData = flvWriter.onVideoExtraData
-	demuxer.OnAudioExtraData = flvWriter.onAudioExtraData
-	demuxer.OnVideoSample = flvWriter.onVideoSample
-	demuxer.OnAudioSample = flvWriter.onAudioSample
-
+	flvWriter := flv.NewFlvWriter(w)
+	hasWritten := false
+	ts := int64(0)       // 初始化时间戳
+	tsOffset := int64(0) // 偏移时间戳
 	// 执行解复用和转换
-	err := demuxer.Demux(r.Context())
+	err := demuxer.Demux(r.Context(),
+		func(audio *rtmp.RTMPAudio) error {
+			if !hasWritten {
+				if err := flvWriter.WriteHeader(demuxer.AudioTrack != nil, demuxer.VideoTrack != nil); err != nil {
+					return err
+				}
+			}
+
+			// 计算调整后的时间戳
+			ts = int64(audio.Timestamp) + tsOffset
+			timestamp := uint32(ts)
+
+			// 写入音频数据帧
+			return flvWriter.WriteTag(flv.FLV_TAG_TYPE_AUDIO, timestamp, uint32(audio.Size), audio.Buffers...)
+		}, func(frame *rtmp.RTMPVideo) error {
+			if !hasWritten {
+				if err := flvWriter.WriteHeader(demuxer.AudioTrack != nil, demuxer.VideoTrack != nil); err != nil {
+					return err
+				}
+			}
+			// 计算调整后的时间戳
+			ts = int64(frame.Timestamp) + tsOffset
+			timestamp := uint32(ts)
+			// 写入视频数据帧
+			return flvWriter.WriteTag(flv.FLV_TAG_TYPE_VIDEO, timestamp, uint32(frame.Size), frame.Buffers...)
+		})
 	if err != nil {
 		plugin.Error("MP4 to FLV conversion failed", "err", err)
-		if !flvWriter.hasWritten {
+		if !hasWritten {
 			http.Error(w, "Conversion failed", http.StatusInternalServerError)
 		}
 		return
@@ -231,160 +249,6 @@ func (plugin *FLVPlugin) processMp4ToFlv(w http.ResponseWriter, r *http.Request,
 	plugin.Info("MP4 to FLV conversion completed")
 }
 
-type ExtraDataInfo struct {
-	CodecType box.MP4_CODEC_TYPE
-	Data      []byte
-}
-
-// flvMp4Writer 处理MP4到FLV的转换写入
-type flvMp4Writer struct {
-	*flv.FlvWriter
-	plugin                 *FLVPlugin
-	audioExtra, videoExtra *ExtraDataInfo
-	hasWritten             bool  // 是否已经写入FLV头
-	ts                     int64 // 当前时间戳
-	tsOffset               int64 // 时间戳偏移量，用于多文件连续播放
-}
-
-// writeFlvHeader 写入FLV文件头
-func (w *flvMp4Writer) writeFlvHeader() error {
-	if w.hasWritten {
-		return nil
-	}
-
-	// 使用 FlvWriter 的 WriteHeader 方法
-	err := w.FlvWriter.WriteHeader(w.audioExtra != nil, w.videoExtra != nil) // 有音频和视频
-	if err != nil {
-		return err
-	}
-	w.hasWritten = true
-	if w.videoExtra != nil {
-		w.onVideoExtraData(w.videoExtra.CodecType, w.videoExtra.Data)
-	}
-	if w.audioExtra != nil {
-		w.onAudioExtraData(w.audioExtra.CodecType, w.audioExtra.Data)
-	}
-	return nil
-}
-
-// onVideoExtraData 处理视频序列头
-func (w *flvMp4Writer) onVideoExtraData(codecType box.MP4_CODEC_TYPE, data []byte) error {
-	if !w.hasWritten {
-		w.videoExtra = &ExtraDataInfo{
-			CodecType: codecType,
-			Data:      data,
-		}
-		return nil
-	}
-	switch codecType {
-	case box.MP4_CODEC_H264:
-		return w.WriteTag(flv.FLV_TAG_TYPE_VIDEO, uint32(w.ts), uint32(len(data)+5), []byte{(1 << 4) | 7, 0, 0, 0, 0}, data)
-	case box.MP4_CODEC_H265:
-		return w.WriteTag(flv.FLV_TAG_TYPE_VIDEO, uint32(w.ts), uint32(len(data)+5), []byte{0b1001_0000 | rtmp.PacketTypeSequenceStart, codec.FourCC_H265[0], codec.FourCC_H265[1], codec.FourCC_H265[2], codec.FourCC_H265[3]}, data)
-	default:
-		return fmt.Errorf("unsupported video codec: %v", codecType)
-	}
-}
-
-// onAudioExtraData 处理音频序列头
-func (w *flvMp4Writer) onAudioExtraData(codecType box.MP4_CODEC_TYPE, data []byte) error {
-	if !w.hasWritten {
-		w.audioExtra = &ExtraDataInfo{
-			CodecType: codecType,
-			Data:      data,
-		}
-		return nil
-	}
-	var flvCodec byte
-	switch codecType {
-	case box.MP4_CODEC_AAC:
-		flvCodec = 10 // AAC
-	case box.MP4_CODEC_G711A:
-		flvCodec = 7 // G.711 A-law
-	case box.MP4_CODEC_G711U:
-		flvCodec = 8 // G.711 μ-law
-	default:
-		return fmt.Errorf("unsupported audio codec: %v", codecType)
-	}
-
-	// 构建FLV音频标签 - 序列头
-	if flvCodec == 10 { // AAC 需要两个字节头部
-		return w.WriteTag(flv.FLV_TAG_TYPE_AUDIO, uint32(w.ts), uint32(len(data)+2), []byte{(flvCodec << 4) | (3 << 2) | (1 << 1) | 1, 0}, data)
-	} else {
-		return w.WriteTag(flv.FLV_TAG_TYPE_AUDIO, uint32(w.ts), uint32(len(data)+1), []byte{(flvCodec << 4) | (3 << 2) | (1 << 1) | 1}, data)
-	}
-}
-
-// onVideoSample 处理视频样本
-func (w *flvMp4Writer) onVideoSample(codecType box.MP4_CODEC_TYPE, sample box.Sample) error {
-	if !w.hasWritten {
-		if err := w.writeFlvHeader(); err != nil {
-			return err
-		}
-	}
-
-	// 计算调整后的时间戳
-	w.ts = int64(sample.Timestamp) + w.tsOffset
-	timestamp := uint32(w.ts)
-
-	switch codecType {
-	case box.MP4_CODEC_H264:
-		frameType := byte(2) // P帧
-		if sample.KeyFrame {
-			frameType = 1 // I帧
-		}
-		return w.WriteTag(flv.FLV_TAG_TYPE_VIDEO, timestamp, uint32(len(sample.Data)+5), []byte{(frameType << 4) | 7, 1, byte(sample.CTS >> 16), byte(sample.CTS >> 8), byte(sample.CTS)}, sample.Data)
-	case box.MP4_CODEC_H265:
-		// Enhanced RTMP格式用于H.265
-		var b0 byte = 0b1010_0000 // P帧标识
-		if sample.KeyFrame {
-			b0 = 0b1001_0000 // 关键帧标识
-		}
-		if sample.CTS == 0 {
-			// CTS为0时使用PacketTypeCodedFramesX（5字节头）
-			return w.WriteTag(flv.FLV_TAG_TYPE_VIDEO, timestamp, uint32(len(sample.Data)+5), []byte{b0 | rtmp.PacketTypeCodedFramesX, codec.FourCC_H265[0], codec.FourCC_H265[1], codec.FourCC_H265[2], codec.FourCC_H265[3]}, sample.Data)
-		} else {
-			// CTS不为0时使用PacketTypeCodedFrames（8字节头，包含CTS）
-			return w.WriteTag(flv.FLV_TAG_TYPE_VIDEO, timestamp, uint32(len(sample.Data)+8), []byte{b0 | rtmp.PacketTypeCodedFrames, codec.FourCC_H265[0], codec.FourCC_H265[1], codec.FourCC_H265[2], codec.FourCC_H265[3], byte(sample.CTS >> 16), byte(sample.CTS >> 8), byte(sample.CTS)}, sample.Data)
-		}
-	default:
-		return fmt.Errorf("unsupported video codec: %v", codecType)
-	}
-}
-
-// onAudioSample 处理音频样本
-func (w *flvMp4Writer) onAudioSample(codec box.MP4_CODEC_TYPE, sample box.Sample) error {
-	if !w.hasWritten {
-		if err := w.writeFlvHeader(); err != nil {
-			return err
-		}
-	}
-
-	// 计算调整后的时间戳
-	w.ts = int64(sample.Timestamp) + w.tsOffset
-	timestamp := uint32(w.ts)
-
-	var flvCodec byte
-	switch codec {
-	case box.MP4_CODEC_AAC:
-		flvCodec = 10 // AAC
-	case box.MP4_CODEC_G711A:
-		flvCodec = 7 // G.711 A-law
-	case box.MP4_CODEC_G711U:
-		flvCodec = 8 // G.711 μ-law
-	default:
-		return fmt.Errorf("unsupported audio codec: %v", codec)
-	}
-
-	// 构建FLV音频标签 - 音频帧
-	if flvCodec == 10 { // AAC 需要两个字节头部
-		return w.WriteTag(flv.FLV_TAG_TYPE_AUDIO, timestamp, uint32(len(sample.Data)+2), []byte{(flvCodec << 4) | (3 << 2) | (1 << 1) | 1, 1}, sample.Data)
-	} else {
-		// 对于非AAC编解码器（如G.711），只需要一个字节头部
-		return w.WriteTag(flv.FLV_TAG_TYPE_AUDIO, timestamp, uint32(len(sample.Data)+1), []byte{(flvCodec << 4) | (3 << 2) | (1 << 1) | 1}, sample.Data)
-	}
-}
-
 // processFlvFiles 处理原生FLV文件
 func (plugin *FLVPlugin) processFlvFiles(w http.ResponseWriter, r *http.Request, fileInfoList []*fileInfo, params *requestParams) {
 	plugin.Info("Processing FLV files", "count", len(fileInfoList))

plugin/flv/pb/flv.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.28.1
-// 	protoc        v3.19.1
+// 	protoc-gen-go v1.36.6
+// 	protoc        v5.29.3
 // source: flv.proto
 
 package pb
@@ -16,6 +16,7 @@ import (
 	pb "m7s.live/v5/pb"
 	reflect "reflect"
 	sync "sync"
+	unsafe "unsafe"
 )
 
 const (
@@ -26,26 +27,23 @@ const (
 )
 
 type ReqRecordList struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	StreamPath    string                 `protobuf:"bytes,1,opt,name=streamPath,proto3" json:"streamPath,omitempty"`
+	Range         string                 `protobuf:"bytes,2,opt,name=range,proto3" json:"range,omitempty"`
+	Start         string                 `protobuf:"bytes,3,opt,name=start,proto3" json:"start,omitempty"`
+	End           string                 `protobuf:"bytes,4,opt,name=end,proto3" json:"end,omitempty"`
+	PageNum       uint32                 `protobuf:"varint,5,opt,name=pageNum,proto3" json:"pageNum,omitempty"`
+	PageSize      uint32                 `protobuf:"varint,6,opt,name=pageSize,proto3" json:"pageSize,omitempty"`
+	Mode          string                 `protobuf:"bytes,7,opt,name=mode,proto3" json:"mode,omitempty"`
 	unknownFields protoimpl.UnknownFields
-
-	StreamPath string `protobuf:"bytes,1,opt,name=streamPath,proto3" json:"streamPath,omitempty"`
-	Range      string `protobuf:"bytes,2,opt,name=range,proto3" json:"range,omitempty"`
-	Start      string `protobuf:"bytes,3,opt,name=start,proto3" json:"start,omitempty"`
-	End        string `protobuf:"bytes,4,opt,name=end,proto3" json:"end,omitempty"`
-	PageNum    uint32 `protobuf:"varint,5,opt,name=pageNum,proto3" json:"pageNum,omitempty"`
-	PageSize   uint32 `protobuf:"varint,6,opt,name=pageSize,proto3" json:"pageSize,omitempty"`
-	Mode       string `protobuf:"bytes,7,opt,name=mode,proto3" json:"mode,omitempty"`
+	sizeCache     protoimpl.SizeCache
 }
 
 func (x *ReqRecordList) Reset() {
 	*x = ReqRecordList{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_flv_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
+	mi := &file_flv_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
 }
 
 func (x *ReqRecordList) String() string {
@@ -56,7 +54,7 @@ func (*ReqRecordList) ProtoMessage() {}
 
 func (x *ReqRecordList) ProtoReflect() protoreflect.Message {
 	mi := &file_flv_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
+	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
 			ms.StoreMessageInfo(mi)
@@ -121,24 +119,21 @@ func (x *ReqRecordList) GetMode() string {
 }
 
 type ReqRecordDelete struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	StreamPath    string                 `protobuf:"bytes,1,opt,name=streamPath,proto3" json:"streamPath,omitempty"`
+	Ids           []uint32               `protobuf:"varint,2,rep,packed,name=ids,proto3" json:"ids,omitempty"`
+	StartTime     string                 `protobuf:"bytes,3,opt,name=startTime,proto3" json:"startTime,omitempty"`
+	EndTime       string                 `protobuf:"bytes,4,opt,name=endTime,proto3" json:"endTime,omitempty"`
+	Range         string                 `protobuf:"bytes,5,opt,name=range,proto3" json:"range,omitempty"`
 	unknownFields protoimpl.UnknownFields
-
-	StreamPath string   `protobuf:"bytes,1,opt,name=streamPath,proto3" json:"streamPath,omitempty"`
-	Ids        []uint32 `protobuf:"varint,2,rep,packed,name=ids,proto3" json:"ids,omitempty"`
-	StartTime  string   `protobuf:"bytes,3,opt,name=startTime,proto3" json:"startTime,omitempty"`
-	EndTime    string   `protobuf:"bytes,4,opt,name=endTime,proto3" json:"endTime,omitempty"`
-	Range      string   `protobuf:"bytes,5,opt,name=range,proto3" json:"range,omitempty"`
+	sizeCache     protoimpl.SizeCache
 }
 
 func (x *ReqRecordDelete) Reset() {
 	*x = ReqRecordDelete{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_flv_proto_msgTypes[1]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
+	mi := &file_flv_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
 }
 
 func (x *ReqRecordDelete) String() string {
@@ -149,7 +144,7 @@ func (*ReqRecordDelete) ProtoMessage() {}
 
 func (x *ReqRecordDelete) ProtoReflect() protoreflect.Message {
 	mi := &file_flv_proto_msgTypes[1]
-	if protoimpl.UnsafeEnabled && x != nil {
+	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
 			ms.StoreMessageInfo(mi)
@@ -201,86 +196,58 @@ func (x *ReqRecordDelete) GetRange() string {
 
 var File_flv_proto protoreflect.FileDescriptor
 
-var file_flv_proto_rawDesc = []byte{
-	0x0a, 0x09, 0x66, 0x6c, 0x76, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x66, 0x6c, 0x76,
-	0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e,
-	0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b,
-	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f,
-	0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f,
-	0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d,
-	0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f,
-	0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75,
-	0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x0c, 0x67, 0x6c,
-	0x6f, 0x62, 0x61, 0x6c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xb7, 0x01, 0x0a, 0x0d, 0x52,
-	0x65, 0x71, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x1e, 0x0a, 0x0a,
-	0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x0a, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x74, 0x68, 0x12, 0x14, 0x0a, 0x05,
-	0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x72, 0x61, 0x6e,
-	0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18,
-	0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61,
-	0x67, 0x65, 0x4e, 0x75, 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x70, 0x61, 0x67,
-	0x65, 0x4e, 0x75, 0x6d, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x61, 0x67, 0x65, 0x53, 0x69, 0x7a, 0x65,
-	0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x70, 0x61, 0x67, 0x65, 0x53, 0x69, 0x7a, 0x65,
-	0x12, 0x12, 0x0a, 0x04, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04,
-	0x6d, 0x6f, 0x64, 0x65, 0x22, 0x91, 0x01, 0x0a, 0x0f, 0x52, 0x65, 0x71, 0x52, 0x65, 0x63, 0x6f,
-	0x72, 0x64, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x74, 0x72, 0x65,
-	0x61, 0x6d, 0x50, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x74,
-	0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x74, 0x68, 0x12, 0x10, 0x0a, 0x03, 0x69, 0x64, 0x73, 0x18,
-	0x02, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x03, 0x69, 0x64, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x74,
-	0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73,
-	0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x64, 0x54,
-	0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69,
-	0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x05, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x32, 0x98, 0x02, 0x0a, 0x03, 0x61, 0x70, 0x69,
-	0x12, 0x57, 0x0a, 0x04, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x12, 0x2e, 0x66, 0x6c, 0x76, 0x2e, 0x52,
-	0x65, 0x71, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x4c, 0x69, 0x73, 0x74, 0x1a, 0x14, 0x2e, 0x67,
-	0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x4c, 0x69,
-	0x73, 0x74, 0x22, 0x25, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x12, 0x1d, 0x2f, 0x66, 0x6c, 0x76,
-	0x2f, 0x61, 0x70, 0x69, 0x2f, 0x6c, 0x69, 0x73, 0x74, 0x2f, 0x7b, 0x73, 0x74, 0x72, 0x65, 0x61,
-	0x6d, 0x50, 0x61, 0x74, 0x68, 0x3d, 0x2a, 0x2a, 0x7d, 0x12, 0x54, 0x0a, 0x07, 0x43, 0x61, 0x74,
-	0x61, 0x6c, 0x6f, 0x67, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x17, 0x2e, 0x67,
-	0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x43, 0x61,
-	0x74, 0x61, 0x6c, 0x6f, 0x67, 0x22, 0x18, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x12, 0x10, 0x2f,
-	0x66, 0x6c, 0x76, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x12,
-	0x62, 0x0a, 0x06, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x14, 0x2e, 0x66, 0x6c, 0x76, 0x2e,
-	0x52, 0x65, 0x71, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x1a,
-	0x16, 0x2e, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x22, 0x2a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x24, 0x22,
-	0x1f, 0x2f, 0x66, 0x6c, 0x76, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65,
-	0x2f, 0x7b, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x74, 0x68, 0x3d, 0x2a, 0x2a, 0x7d,
-	0x3a, 0x01, 0x2a, 0x42, 0x1b, 0x5a, 0x19, 0x6d, 0x37, 0x73, 0x2e, 0x6c, 0x69, 0x76, 0x65, 0x2f,
-	0x76, 0x35, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x2f, 0x66, 0x6c, 0x76, 0x2f, 0x70, 0x62,
-	0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
+const file_flv_proto_rawDesc = "" +
+	"\n" +
+	"\tflv.proto\x12\x03flv\x1a\x1cgoogle/api/annotations.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\fglobal.proto\"\xb7\x01\n" +
+	"\rReqRecordList\x12\x1e\n" +
+	"\n" +
+	"streamPath\x18\x01 \x01(\tR\n" +
+	"streamPath\x12\x14\n" +
+	"\x05range\x18\x02 \x01(\tR\x05range\x12\x14\n" +
+	"\x05start\x18\x03 \x01(\tR\x05start\x12\x10\n" +
+	"\x03end\x18\x04 \x01(\tR\x03end\x12\x18\n" +
+	"\apageNum\x18\x05 \x01(\rR\apageNum\x12\x1a\n" +
+	"\bpageSize\x18\x06 \x01(\rR\bpageSize\x12\x12\n" +
+	"\x04mode\x18\a \x01(\tR\x04mode\"\x91\x01\n" +
+	"\x0fReqRecordDelete\x12\x1e\n" +
+	"\n" +
+	"streamPath\x18\x01 \x01(\tR\n" +
+	"streamPath\x12\x10\n" +
+	"\x03ids\x18\x02 \x03(\rR\x03ids\x12\x1c\n" +
+	"\tstartTime\x18\x03 \x01(\tR\tstartTime\x12\x18\n" +
+	"\aendTime\x18\x04 \x01(\tR\aendTime\x12\x14\n" +
+	"\x05range\x18\x05 \x01(\tR\x05range2\x9e\x02\n" +
+	"\x03api\x12]\n" +
+	"\x04List\x12\x12.flv.ReqRecordList\x1a\x1a.global.RecordResponseList\"%\x82\xd3\xe4\x93\x02\x1f\x12\x1d/flv/api/list/{streamPath=**}\x12T\n" +
+	"\aCatalog\x12\x16.google.protobuf.Empty\x1a\x17.global.ResponseCatalog\"\x18\x82\xd3\xe4\x93\x02\x12\x12\x10/flv/api/catalog\x12b\n" +
+	"\x06Delete\x12\x14.flv.ReqRecordDelete\x1a\x16.global.ResponseDelete\"*\x82\xd3\xe4\x93\x02$:\x01*\"\x1f/flv/api/delete/{streamPath=**}B\x1bZ\x19m7s.live/v5/plugin/flv/pbb\x06proto3"
 
 var (
 	file_flv_proto_rawDescOnce sync.Once
-	file_flv_proto_rawDescData = file_flv_proto_rawDesc
+	file_flv_proto_rawDescData []byte
 )
 
 func file_flv_proto_rawDescGZIP() []byte {
 	file_flv_proto_rawDescOnce.Do(func() {
-		file_flv_proto_rawDescData = protoimpl.X.CompressGZIP(file_flv_proto_rawDescData)
+		file_flv_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_flv_proto_rawDesc), len(file_flv_proto_rawDesc)))
 	})
 	return file_flv_proto_rawDescData
 }
 
 var file_flv_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
-var file_flv_proto_goTypes = []interface{}{
-	(*ReqRecordList)(nil),      // 0: flv.ReqRecordList
-	(*ReqRecordDelete)(nil),    // 1: flv.ReqRecordDelete
-	(*emptypb.Empty)(nil),      // 2: google.protobuf.Empty
-	(*pb.ResponseList)(nil),    // 3: global.ResponseList
-	(*pb.ResponseCatalog)(nil), // 4: global.ResponseCatalog
-	(*pb.ResponseDelete)(nil),  // 5: global.ResponseDelete
+var file_flv_proto_goTypes = []any{
+	(*ReqRecordList)(nil),         // 0: flv.ReqRecordList
+	(*ReqRecordDelete)(nil),       // 1: flv.ReqRecordDelete
+	(*emptypb.Empty)(nil),         // 2: google.protobuf.Empty
+	(*pb.RecordResponseList)(nil), // 3: global.RecordResponseList
+	(*pb.ResponseCatalog)(nil),    // 4: global.ResponseCatalog
+	(*pb.ResponseDelete)(nil),     // 5: global.ResponseDelete
 }
 var file_flv_proto_depIdxs = []int32{
 	0, // 0: flv.api.List:input_type -> flv.ReqRecordList
 	2, // 1: flv.api.Catalog:input_type -> google.protobuf.Empty
 	1, // 2: flv.api.Delete:input_type -> flv.ReqRecordDelete
-	3, // 3: flv.api.List:output_type -> global.ResponseList
+	3, // 3: flv.api.List:output_type -> global.RecordResponseList
 	4, // 4: flv.api.Catalog:output_type -> global.ResponseCatalog
 	5, // 5: flv.api.Delete:output_type -> global.ResponseDelete
 	3, // [3:6] is the sub-list for method output_type
@@ -295,37 +262,11 @@ func file_flv_proto_init() {
 	if File_flv_proto != nil {
 		return
 	}
-	if !protoimpl.UnsafeEnabled {
-		file_flv_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ReqRecordList); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_flv_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ReqRecordDelete); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
 		File: protoimpl.DescBuilder{
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_flv_proto_rawDesc,
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_flv_proto_rawDesc), len(file_flv_proto_rawDesc)),
 			NumEnums:      0,
 			NumMessages:   2,
 			NumExtensions: 0,
@@ -336,7 +277,6 @@ func file_flv_proto_init() {
 		MessageInfos:      file_flv_proto_msgTypes,
 	}.Build()
 	File_flv_proto = out.File
-	file_flv_proto_rawDesc = nil
 	file_flv_proto_goTypes = nil
 	file_flv_proto_depIdxs = nil
 }

plugin/flv/pb/flv.proto

@@ -8,7 +8,7 @@ package flv;
 option go_package="m7s.live/v5/plugin/flv/pb";
 
 service api {
-  rpc List (ReqRecordList) returns (global.ResponseList) {
+  rpc List (ReqRecordList) returns (global.RecordResponseList) {
     option (google.api.http) = {
       get: "/flv/api/list/{streamPath=**}"
     };

plugin/flv/pb/flv_grpc.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
-// - protoc-gen-go-grpc v1.2.0
-// - protoc             v3.19.1
+// - protoc-gen-go-grpc v1.5.1
+// - protoc             v5.29.3
 // source: flv.proto
 
 package pb
@@ -17,14 +17,20 @@ import (
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
-const _ = grpc.SupportPackageIsVersion7
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	Api_List_FullMethodName    = "/flv.api/List"
+	Api_Catalog_FullMethodName = "/flv.api/Catalog"
+	Api_Delete_FullMethodName  = "/flv.api/Delete"
+)
 
 // ApiClient is the client API for Api service.
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type ApiClient interface {
-	List(ctx context.Context, in *ReqRecordList, opts ...grpc.CallOption) (*pb.ResponseList, error)
+	List(ctx context.Context, in *ReqRecordList, opts ...grpc.CallOption) (*pb.RecordResponseList, error)
 	Catalog(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*pb.ResponseCatalog, error)
 	Delete(ctx context.Context, in *ReqRecordDelete, opts ...grpc.CallOption) (*pb.ResponseDelete, error)
 }
@@ -37,9 +43,10 @@ func NewApiClient(cc grpc.ClientConnInterface) ApiClient {
 	return &apiClient{cc}
 }
 
-func (c *apiClient) List(ctx context.Context, in *ReqRecordList, opts ...grpc.CallOption) (*pb.ResponseList, error) {
-	out := new(pb.ResponseList)
-	err := c.cc.Invoke(ctx, "/flv.api/List", in, out, opts...)
+func (c *apiClient) List(ctx context.Context, in *ReqRecordList, opts ...grpc.CallOption) (*pb.RecordResponseList, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(pb.RecordResponseList)
+	err := c.cc.Invoke(ctx, Api_List_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -47,8 +54,9 @@ func (c *apiClient) List(ctx context.Context, in *ReqRecordList, opts ...grpc.Ca
 }
 
 func (c *apiClient) Catalog(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*pb.ResponseCatalog, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(pb.ResponseCatalog)
-	err := c.cc.Invoke(ctx, "/flv.api/Catalog", in, out, opts...)
+	err := c.cc.Invoke(ctx, Api_Catalog_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -56,8 +64,9 @@ func (c *apiClient) Catalog(ctx context.Context, in *emptypb.Empty, opts ...grpc
 }
 
 func (c *apiClient) Delete(ctx context.Context, in *ReqRecordDelete, opts ...grpc.CallOption) (*pb.ResponseDelete, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(pb.ResponseDelete)
-	err := c.cc.Invoke(ctx, "/flv.api/Delete", in, out, opts...)
+	err := c.cc.Invoke(ctx, Api_Delete_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -66,19 +75,22 @@ func (c *apiClient) Delete(ctx context.Context, in *ReqRecordDelete, opts ...grp
 
 // ApiServer is the server API for Api service.
 // All implementations must embed UnimplementedApiServer
-// for forward compatibility
+// for forward compatibility.
 type ApiServer interface {
-	List(context.Context, *ReqRecordList) (*pb.ResponseList, error)
+	List(context.Context, *ReqRecordList) (*pb.RecordResponseList, error)
 	Catalog(context.Context, *emptypb.Empty) (*pb.ResponseCatalog, error)
 	Delete(context.Context, *ReqRecordDelete) (*pb.ResponseDelete, error)
 	mustEmbedUnimplementedApiServer()
 }
 
-// UnimplementedApiServer must be embedded to have forward compatible implementations.
-type UnimplementedApiServer struct {
-}
+// UnimplementedApiServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedApiServer struct{}
 
-func (UnimplementedApiServer) List(context.Context, *ReqRecordList) (*pb.ResponseList, error) {
+func (UnimplementedApiServer) List(context.Context, *ReqRecordList) (*pb.RecordResponseList, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
 }
 func (UnimplementedApiServer) Catalog(context.Context, *emptypb.Empty) (*pb.ResponseCatalog, error) {
@@ -88,6 +100,7 @@ func (UnimplementedApiServer) Delete(context.Context, *ReqRecordDelete) (*pb.Res
 	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
 }
 func (UnimplementedApiServer) mustEmbedUnimplementedApiServer() {}
+func (UnimplementedApiServer) testEmbeddedByValue()             {}
 
 // UnsafeApiServer may be embedded to opt out of forward compatibility for this service.
 // Use of this interface is not recommended, as added methods to ApiServer will
@@ -97,6 +110,13 @@ type UnsafeApiServer interface {
 }
 
 func RegisterApiServer(s grpc.ServiceRegistrar, srv ApiServer) {
+	// If the following call pancis, it indicates UnimplementedApiServer was
+	// embedded by pointer and is nil.  This will cause panics if an
+	// unimplemented method is ever invoked, so we test this at initialization
+	// time to prevent it from happening at runtime later due to I/O.
+	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+		t.testEmbeddedByValue()
+	}
 	s.RegisterService(&Api_ServiceDesc, srv)
 }
 
@@ -110,7 +130,7 @@ func _Api_List_Handler(srv interface{}, ctx context.Context, dec func(interface{
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/flv.api/List",
+		FullMethod: Api_List_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ApiServer).List(ctx, req.(*ReqRecordList))
@@ -128,7 +148,7 @@ func _Api_Catalog_Handler(srv interface{}, ctx context.Context, dec func(interfa
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/flv.api/Catalog",
+		FullMethod: Api_Catalog_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ApiServer).Catalog(ctx, req.(*emptypb.Empty))
@@ -146,7 +166,7 @@ func _Api_Delete_Handler(srv interface{}, ctx context.Context, dec func(interfac
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/flv.api/Delete",
+		FullMethod: Api_Delete_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ApiServer).Delete(ctx, req.(*ReqRecordDelete))

plugin/flv/pkg/record.go

@@ -5,15 +5,12 @@ import (
 	"io"
 	"os"
 	"path/filepath"
-	"slices"
 	"time"
 
-	"gorm.io/gorm"
 	"m7s.live/v5"
 	"m7s.live/v5/pkg"
 	"m7s.live/v5/pkg/config"
 	"m7s.live/v5/pkg/task"
-	"m7s.live/v5/pkg/util"
 	rtmp "m7s.live/v5/plugin/rtmp/pkg"
 )
 
@@ -144,7 +141,8 @@ func NewRecorder(conf config.Record) m7s.IRecorder {
 
 type Recorder struct {
 	m7s.DefaultRecorder
-	stream m7s.RecordStream
+	writer *FlvWriter
+	file   *os.File
 }
 
 var CustomFileName = func(job *m7s.RecordJob) string {
@@ -155,48 +153,34 @@ var CustomFileName = func(job *m7s.RecordJob) string {
 }
 
 func (r *Recorder) createStream(start time.Time) (err error) {
-	recordJob := &r.RecordJob
-	sub := recordJob.Subscriber
-	r.stream = m7s.RecordStream{
-		StartTime:      start,
-		StreamPath:     sub.StreamPath,
-		FilePath:       CustomFileName(&r.RecordJob),
-		EventId:        recordJob.EventId,
-		EventDesc:      recordJob.EventDesc,
-		EventName:      recordJob.EventName,
-		EventLevel:     recordJob.EventLevel,
-		BeforeDuration: recordJob.BeforeDuration,
-		AfterDuration:  recordJob.AfterDuration,
-		Mode:           recordJob.Mode,
-		Type:           "flv",
-	}
-	dir := filepath.Dir(r.stream.FilePath)
-	if err = os.MkdirAll(dir, 0755); err != nil {
+	r.RecordJob.RecConf.Type = "flv"
+	err = r.CreateStream(start, CustomFileName)
+	if err != nil {
 		return
 	}
-	if sub.Publisher.HasAudioTrack() {
-		r.stream.AudioCodec = sub.Publisher.AudioTrack.ICodecCtx.String()
+	if r.file, err = os.OpenFile(r.Event.FilePath, os.O_CREATE|os.O_RDWR, 0666); err != nil {
+		return
 	}
-	if sub.Publisher.HasVideoTrack() {
-		r.stream.VideoCodec = sub.Publisher.VideoTrack.ICodecCtx.String()
-	}
-	if recordJob.Plugin.DB != nil {
-		recordJob.Plugin.DB.Save(&r.stream)
+	_, err = r.file.Write(FLVHead)
+	r.writer = NewFlvWriter(r.file)
+	if err != nil {
+		return
 	}
 	return
 }
 
 func (r *Recorder) writeTailer(end time.Time) {
-	if r.stream.EndTime.After(r.stream.StartTime) {
+	if r.Event.EndTime.After(r.Event.StartTime) {
 		return
 	}
-	r.stream.EndTime = end
+	r.Event.EndTime = end
 	if r.RecordJob.Plugin.DB != nil {
-		r.RecordJob.Plugin.DB.Save(&r.stream)
-		writeMetaTagQueueTask.AddTask(&eventRecordCheck{
-			DB:         r.RecordJob.Plugin.DB,
-			streamPath: r.stream.StreamPath,
-		})
+		if r.RecordJob.Event != nil {
+			r.RecordJob.Plugin.DB.Save(&r.Event)
+		} else {
+			r.RecordJob.Plugin.DB.Save(&r.Event.RecordStream)
+		}
+		writeMetaTagQueueTask.AddTask(m7s.NewEventRecordCheck(r.Event.Type, r.Event.StreamPath, r.RecordJob.Plugin.DB))
 	}
 }
 
@@ -204,42 +188,7 @@ func (r *Recorder) Dispose() {
 	r.writeTailer(time.Now())
 }
 
-type eventRecordCheck struct {
-	task.Task
-	DB         *gorm.DB
-	streamPath string
-}
-
-func (t *eventRecordCheck) Run() (err error) {
-	var eventRecordStreams []m7s.RecordStream
-	queryRecord := m7s.RecordStream{
-		EventLevel: m7s.EventLevelHigh,
-		Mode:       m7s.RecordModeEvent,
-		Type:       "flv",
-	}
-	t.DB.Where(&queryRecord).Find(&eventRecordStreams, "stream_path=?", t.streamPath) //搜索事件录像，且为重要事件（无法自动删除）
-	if len(eventRecordStreams) > 0 {
-		for _, recordStream := range eventRecordStreams {
-			var unimportantEventRecordStreams []m7s.RecordStream
-			queryRecord.EventLevel = m7s.EventLevelLow
-			query := `(start_time BETWEEN ? AND ?)
-							OR (end_time BETWEEN ? AND ?) 
-							OR (? BETWEEN start_time AND end_time) 
-							OR (? BETWEEN start_time AND end_time) AND stream_path=? `
-			t.DB.Where(&queryRecord).Where(query, recordStream.StartTime, recordStream.EndTime, recordStream.StartTime, recordStream.EndTime, recordStream.StartTime, recordStream.EndTime, recordStream.StreamPath).Find(&unimportantEventRecordStreams)
-			if len(unimportantEventRecordStreams) > 0 {
-				for _, unimportantEventRecordStream := range unimportantEventRecordStreams {
-					unimportantEventRecordStream.EventLevel = m7s.EventLevelHigh
-					t.DB.Save(&unimportantEventRecordStream)
-				}
-			}
-		}
-	}
-	return
-}
-
 func (r *Recorder) Run() (err error) {
-	var file *os.File
 	var filepositions []uint64
 	var times []float64
 	var offset int64
@@ -247,82 +196,27 @@ func (r *Recorder) Run() (err error) {
 	ctx := &r.RecordJob
 	suber := ctx.Subscriber
 	noFragment := ctx.RecConf.Fragment == 0 || ctx.RecConf.Append
-	startTime := time.Now()
-	if ctx.BeforeDuration > 0 {
-		startTime = startTime.Add(-ctx.BeforeDuration)
-	}
-	if err = r.createStream(startTime); err != nil {
-		return
-	}
-	if noFragment {
-		file, err = os.OpenFile(r.stream.FilePath, os.O_CREATE|os.O_RDWR|util.Conditional(ctx.RecConf.Append, os.O_APPEND, os.O_TRUNC), 0666)
-		if err != nil {
-			return
-		}
-		defer writeMetaTag(file, suber, filepositions, times, &duration)
-	}
-	if ctx.RecConf.Append {
-		var metaData rtmp.EcmaArray
-		metaData, err = ReadMetaData(file)
-		keyframes := metaData["keyframes"].(map[string]any)
-		filepositions = slices.Collect(func(yield func(uint64) bool) {
-			for _, v := range keyframes["filepositions"].([]float64) {
-				yield(uint64(v))
-			}
-		})
-		times = keyframes["times"].([]float64)
-		if _, err = file.Seek(-4, io.SeekEnd); err != nil {
-			ctx.Error("seek file failed", "err", err)
-			_, err = file.Write(FLVHead)
-		} else {
-			tmp := make(util.Buffer, 4)
-			tmp2 := tmp
-			_, err = file.Read(tmp)
-			tagSize := tmp.ReadUint32()
-			tmp = tmp2
-			_, err = file.Seek(int64(tagSize), io.SeekEnd)
-			_, err = file.Read(tmp2)
-			ts := tmp2.ReadUint24() | (uint32(tmp[3]) << 24)
-			ctx.Info("append flv", "last tagSize", tagSize, "last ts", ts)
-			suber.StartAudioTS = time.Duration(ts) * time.Millisecond
-			suber.StartVideoTS = time.Duration(ts) * time.Millisecond
-			offset, err = file.Seek(0, io.SeekEnd)
-		}
-	} else if ctx.RecConf.Fragment == 0 {
-		_, err = file.Write(FLVHead)
-	} else {
-		if file, err = os.OpenFile(r.stream.FilePath, os.O_CREATE|os.O_RDWR, 0666); err != nil {
-			return
-		}
-		_, err = file.Write(FLVHead)
-	}
-	writer := NewFlvWriter(file)
-	checkFragment := func(absTime uint32) {
+	checkFragment := func(absTime uint32, writeTime time.Time) {
 		if duration = int64(absTime); time.Duration(duration)*time.Millisecond >= ctx.RecConf.Fragment {
-			writeMetaTag(file, suber, filepositions, times, &duration)
-			r.writeTailer(time.Now())
+			writeMetaTag(r.file, suber, filepositions, times, &duration)
+			r.writeTailer(writeTime)
 			filepositions = []uint64{0}
 			times = []float64{0}
 			offset = 0
-			if err = r.createStream(time.Now()); err != nil {
+			if err = r.createStream(writeTime); err != nil {
 				return
 			}
-			if file, err = os.OpenFile(r.stream.FilePath, os.O_CREATE|os.O_RDWR, 0666); err != nil {
-				return
-			}
-			_, err = file.Write(FLVHead)
-			writer = NewFlvWriter(file)
 			if vr := suber.VideoReader; vr != nil {
 				vr.ResetAbsTime()
 				seq := vr.Track.SequenceFrame.(*rtmp.RTMPVideo)
-				err = writer.WriteTag(FLV_TAG_TYPE_VIDEO, 0, uint32(seq.Size), seq.Buffers...)
+				err = r.writer.WriteTag(FLV_TAG_TYPE_VIDEO, 0, uint32(seq.Size), seq.Buffers...)
 				offset = int64(seq.Size + 15)
 			}
 			if ar := suber.AudioReader; ar != nil {
 				ar.ResetAbsTime()
 				if ar.Track.SequenceFrame != nil {
 					seq := ar.Track.SequenceFrame.(*rtmp.RTMPAudio)
-					err = writer.WriteTag(FLV_TAG_TYPE_AUDIO, 0, uint32(seq.Size), seq.Buffers...)
+					err = r.writer.WriteTag(FLV_TAG_TYPE_AUDIO, 0, uint32(seq.Size), seq.Buffers...)
 					offset += int64(seq.Size + 15)
 				}
 			}
@@ -330,21 +224,33 @@ func (r *Recorder) Run() (err error) {
 	}
 
 	return m7s.PlayBlock(ctx.Subscriber, func(audio *rtmp.RTMPAudio) (err error) {
-		if suber.VideoReader == nil && !noFragment {
-			checkFragment(suber.AudioReader.AbsTime)
+		if r.Event.StartTime.IsZero() {
+			err = r.createStream(suber.AudioReader.Value.WriteTime)
+			if err != nil {
+				return err
+			}
 		}
-		err = writer.WriteTag(FLV_TAG_TYPE_AUDIO, suber.AudioReader.AbsTime, uint32(audio.Size), audio.Buffers...)
+		if suber.VideoReader == nil && !noFragment {
+			checkFragment(suber.AudioReader.AbsTime, suber.AudioReader.Value.WriteTime)
+		}
+		err = r.writer.WriteTag(FLV_TAG_TYPE_AUDIO, suber.AudioReader.AbsTime, uint32(audio.Size), audio.Buffers...)
 		offset += int64(audio.Size + 15)
 		return
 	}, func(video *rtmp.RTMPVideo) (err error) {
+		if r.Event.StartTime.IsZero() {
+			err = r.createStream(suber.VideoReader.Value.WriteTime)
+			if err != nil {
+				return err
+			}
+		}
 		if suber.VideoReader.Value.IDR {
 			filepositions = append(filepositions, uint64(offset))
 			times = append(times, float64(suber.VideoReader.AbsTime)/1000)
 			if !noFragment {
-				checkFragment(suber.VideoReader.AbsTime)
+				checkFragment(suber.VideoReader.AbsTime, suber.VideoReader.Value.WriteTime)
 			}
 		}
-		err = writer.WriteTag(FLV_TAG_TYPE_VIDEO, suber.VideoReader.AbsTime, uint32(video.Size), video.Buffers...)
+		err = r.writer.WriteTag(FLV_TAG_TYPE_VIDEO, suber.VideoReader.AbsTime, uint32(video.Size), video.Buffers...)
 		offset += int64(video.Size + 15)
 		return
 	})

plugin/gb28181/api.go

@@ -11,6 +11,8 @@ import (
 	"sync"
 	"time"
 
+	"gorm.io/gorm"
+
 	"github.com/emiago/sipgo"
 	"github.com/emiago/sipgo/sip"
 	"m7s.live/v5/pkg/util"
@@ -612,35 +614,47 @@ func (gb *GB28181Plugin) UpdateDevice(ctx context.Context, req *pb.Device) (*pb.
 
 			// 如果需要订阅目录，创建并启动目录订阅任务
 			if d.Online {
-				if d.CatalogSubscribeTask != nil {
-					if d.SubscribeCatalog > 0 {
+				if d.SubscribeCatalog > 0 {
+					if d.CatalogSubscribeTask != nil {
 						d.CatalogSubscribeTask.Ticker.Reset(time.Second * time.Duration(d.SubscribeCatalog))
+						d.CatalogSubscribeTask.Tick(nil)
+					} else {
+						catalogSubTask := NewCatalogSubscribeTask(d)
+						d.AddTask(catalogSubTask)
+						d.CatalogSubscribeTask.Tick(nil)
 					}
-					d.CatalogSubscribeTask.Tick(nil)
 				} else {
-					catalogSubTask := NewCatalogSubscribeTask(d)
-					d.AddTask(catalogSubTask)
-					d.CatalogSubscribeTask.Tick(nil)
+					if d.CatalogSubscribeTask != nil {
+						d.CatalogSubscribeTask.Stop(fmt.Errorf("catalog subscription disabled"))
+					}
 				}
-				if d.PositionSubscribeTask != nil {
-					if d.SubscribePosition > 0 {
+				if d.SubscribePosition > 0 {
+					if d.PositionSubscribeTask != nil {
 						d.PositionSubscribeTask.Ticker.Reset(time.Second * time.Duration(d.SubscribePosition))
+						d.PositionSubscribeTask.Tick(nil)
+					} else {
+						positionSubTask := NewPositionSubscribeTask(d)
+						d.AddTask(positionSubTask)
+						d.PositionSubscribeTask.Tick(nil)
 					}
-					d.PositionSubscribeTask.Tick(nil)
 				} else {
-					positionSubTask := NewPositionSubscribeTask(d)
-					d.AddTask(positionSubTask)
-					d.PositionSubscribeTask.Tick(nil)
+					if d.PositionSubscribeTask != nil {
+						d.PositionSubscribeTask.Stop(fmt.Errorf("position subscription disabled"))
+					}
 				}
-				if d.AlarmSubscribeTask != nil {
-					if d.SubscribeAlarm > 0 {
+				if d.SubscribeAlarm > 0 {
+					if d.AlarmSubscribeTask != nil {
 						d.AlarmSubscribeTask.Ticker.Reset(time.Second * time.Duration(d.SubscribeAlarm))
+						d.AlarmSubscribeTask.Tick(nil)
+					} else {
+						alarmSubTask := NewAlarmSubscribeTask(d)
+						d.AddTask(alarmSubTask)
+						d.AlarmSubscribeTask.Tick(nil)
 					}
-					d.AlarmSubscribeTask.Tick(nil)
 				} else {
-					alarmSubTask := NewAlarmSubscribeTask(d)
-					d.AddTask(alarmSubTask)
-					d.AlarmSubscribeTask.Tick(nil)
+					if d.AlarmSubscribeTask != nil {
+						d.AlarmSubscribeTask.Stop(fmt.Errorf("alarm subscription disabled"))
+					}
 				}
 			}
 		} else {
@@ -1272,32 +1286,36 @@ func (gb *GB28181Plugin) TestSip(ctx context.Context, req *pb.TestSipRequest) (*
 	// 创建一个临时设备用于测试
 	device := &Device{
 		DeviceId:   "34020000002000000001",
-		SipIp:      "192.168.1.17",
+		SipIp:      "192.168.1.106",
 		Port:       5060,
 		IP:         "192.168.1.102",
 		StreamMode: "TCP-PASSIVE",
 	}
-
+	//From: <sip:41010500002000000001@4101050000>;tag=4183af2ecc934758ad393dfe588f2dfd
 	// 初始化设备的SIP相关字段
 	device.fromHDR = sip.FromHeader{
 		Address: sip.Uri{
-			User: gb.Serial,
-			Host: gb.Realm,
+			User: "41010500002000000001",
+			Host: "4101050000",
 		},
 		Params: sip.NewParams(),
 	}
-	device.fromHDR.Params.Add("tag", sip.GenerateTagN(16))
-
+	device.fromHDR.Params.Add("tag", "4183af2ecc934758ad393dfe588f2dfd")
+	//Contact: <sip:41010500002000000001@192.168.1.106:5060>
 	device.contactHDR = sip.ContactHeader{
 		Address: sip.Uri{
-			User: gb.Serial,
-			Host: device.SipIp,
-			Port: device.Port,
+			User: "41010500002000000001",
+			Host: "192.168.1.106",
+			Port: 5060,
 		},
 	}
 
+	//Request-Line: INVITE sip:34020000001320000006@192.168.1.102:5060 SIP/2.0
+	//    Method: INVITE
+	//    Request-URI: sip:34020000001320000006@192.168.1.102:5060
+	//    [Resent Packet: False]
 	// 初始化SIP客户端
-	device.client, _ = sipgo.NewClient(gb.ua, sipgo.WithClientLogger(zerolog.New(os.Stdout)), sipgo.WithClientHostname(device.SipIp))
+	device.client, _ = sipgo.NewClient(gb.ua, sipgo.WithClientLogger(zerolog.New(os.Stdout)), sipgo.WithClientHostname("192.168.1.106"))
 	if device.client == nil {
 		resp.Code = 500
 		resp.Message = "failed to create sip client"
@@ -1322,11 +1340,11 @@ func (gb *GB28181Plugin) TestSip(ctx context.Context, req *pb.TestSipRequest) (*
 	// 构建SDP消息体
 	sdpInfo := []string{
 		"v=0",
-		fmt.Sprintf("o=%s 0 0 IN IP4 %s", "34020000001320000004", device.SipIp),
+		fmt.Sprintf("o=%s 0 0 IN IP4 %s", "34020000001320000102", "192.168.1.106"),
 		"s=Play",
-		"c=IN IP4 " + device.SipIp,
+		"c=IN IP4 192.168.1.106",
 		"t=0 0",
-		"m=video 43970 TCP/RTP/AVP 96 97 98 99",
+		"m=video 40940 TCP/RTP/AVP 96 97 98 99",
 		"a=recvonly",
 		"a=rtpmap:96 PS/90000",
 		"a=rtpmap:98 H264/90000",
@@ -1334,36 +1352,40 @@ func (gb *GB28181Plugin) TestSip(ctx context.Context, req *pb.TestSipRequest) (*
 		"a=rtpmap:99 H265/90000",
 		"a=setup:passive",
 		"a=connection:new",
-		"y=0200005507",
+		"y=0105006213",
 	}
 
 	// 设置必需的头部
 	contentTypeHeader := sip.ContentTypeHeader("APPLICATION/SDP")
-	subjectHeader := sip.NewHeader("Subject", "34020000001320000006:0200005507,34020000002000000001:0")
+	//Subject: 34020000001320000006:0105006213,41010500002000000001:0
+	subjectHeader := sip.NewHeader("Subject", "34020000001320000006:0105006213,41010500002000000001:0")
+
+	//To: <sip:34020000001320000006@192.168.1.102:5060>
 	toHeader := sip.ToHeader{
 		Address: sip.Uri{
 			User: "34020000001320000006",
-			Host: device.IP,
-			Port: device.Port,
+			Host: "192.168.1.102",
+			Port: 5060,
 		},
 	}
 	userAgentHeader := sip.NewHeader("User-Agent", "WVP-Pro v2.7.3.20241218")
+	//Via: SIP/2.0/UDP 192.168.1.106:5060;branch=z9hG4bK9279674404;rport
 	viaHeader := sip.ViaHeader{
 		ProtocolName:    "SIP",
 		ProtocolVersion: "2.0",
 		Transport:       "UDP",
-		Host:            device.SipIp,
-		Port:            device.Port,
+		Host:            "192.168.1.106",
+		Port:            5060,
 		Params:          sip.HeaderParams(sip.NewParams()),
 	}
-	viaHeader.Params.Add("branch", sip.GenerateBranchN(16)).Add("rport", "")
+	viaHeader.Params.Add("branch", "z9hG4bK9279674404").Add("rport", "")
 
 	csqHeader := sip.CSeqHeader{
-		SeqNo:      13,
+		SeqNo:      3,
 		MethodName: "INVITE",
 	}
 	maxforward := sip.MaxForwardsHeader(70)
-	contentLengthHeader := sip.ContentLengthHeader(286)
+	//contentLengthHeader := sip.ContentLengthHeader(288)
 	request.AppendHeader(&contentTypeHeader)
 	request.AppendHeader(subjectHeader)
 	request.AppendHeader(&toHeader)
@@ -1375,7 +1397,7 @@ func (gb *GB28181Plugin) TestSip(ctx context.Context, req *pb.TestSipRequest) (*
 
 	// 创建会话并发送请求
 	dialogClientCache := sipgo.NewDialogClientCache(device.client, device.contactHDR)
-	session, err := dialogClientCache.Invite(gb, recipient, request.Body(), &csqHeader, &device.fromHDR, &toHeader, &viaHeader, &maxforward, userAgentHeader, &device.contactHDR, subjectHeader, &contentTypeHeader, &contentLengthHeader)
+	session, err := dialogClientCache.Invite(gb, recipient, request.Body(), &csqHeader, &device.fromHDR, &toHeader, &maxforward, userAgentHeader, &device.contactHDR, subjectHeader, &contentTypeHeader)
 	if err != nil {
 		resp.Code = 500
 		resp.Message = fmt.Sprintf("发送INVITE请求失败: %v", err)
@@ -1851,8 +1873,8 @@ func (gb *GB28181Plugin) GetGroupChannels(ctx context.Context, req *pb.GetGroupC
 		Select(`
 			IFNULL(gc.id, 0) AS id,
 			dc.channel_id,
+			dc.device_id,
 			dc.name AS channel_name,
-			d.device_id AS device_id,
 			d.name AS device_name,
 			dc.status AS status,
 			CASE
@@ -1861,11 +1883,11 @@ func (gb *GB28181Plugin) GetGroupChannels(ctx context.Context, req *pb.GetGroupC
 			END AS in_group
 		`).
 		Joins("LEFT JOIN "+deviceTable+" AS d ON dc.device_id = d.device_id").
-		Joins("LEFT JOIN "+groupsChannelTable+" AS gc ON dc.channel_id = gc.channel_id AND gc.group_id = ?", req.GroupId)
+		Joins("LEFT JOIN "+groupsChannelTable+" AS gc ON dc.channel_id = gc.channel_id AND dc.device_id = gc.device_id AND gc.group_id = ?", req.GroupId)
 
 	// 如果有设备ID过滤条件
 	if req.DeviceId != "" {
-		baseQuery = baseQuery.Where("d.device_id = ?", req.DeviceId)
+		baseQuery = baseQuery.Where("dc.device_id = ?", req.DeviceId)
 	}
 
 	// 统计符合条件的通道总数
@@ -1881,7 +1903,7 @@ func (gb *GB28181Plugin) GetGroupChannels(ctx context.Context, req *pb.GetGroupC
 	query := baseQuery
 
 	// 添加排序
-	query = query.Order("channel_id ASC")
+	query = query.Order("dc.device_id ASC, dc.channel_id ASC")
 
 	// 如果指定了分页参数，则应用分页
 	if req.Page > 0 && req.Count > 0 {
@@ -1900,12 +1922,14 @@ func (gb *GB28181Plugin) GetGroupChannels(ctx context.Context, req *pb.GetGroupC
 	var pbGroupChannels []*pb.GroupChannel
 	for _, result := range results {
 		channelInfo := &pb.GroupChannel{
+			Id:          int32(result.ID),
+			GroupId:     req.GroupId,
 			ChannelId:   result.ChannelID,
 			DeviceId:    result.DeviceID,
 			ChannelName: result.ChannelName,
 			DeviceName:  result.DeviceName,
 			Status:      result.Status,
-			InGroup:     result.InGroup, // 设置inGroup字段
+			InGroup:     result.InGroup,
 		}
 
 		// 从内存中获取设备信息以获取传输协议
@@ -1913,13 +1937,6 @@ func (gb *GB28181Plugin) GetGroupChannels(ctx context.Context, req *pb.GetGroupC
 			channelInfo.StreamMode = device.StreamMode
 		}
 
-		if result.InGroup {
-			channelInfo.Id = int32(result.ID)
-			channelInfo.GroupId = int32(req.GroupId)
-		} else {
-			channelInfo.Id = 0
-		}
-
 		pbGroupChannels = append(pbGroupChannels, channelInfo)
 	}
 
@@ -2060,19 +2077,19 @@ func (gb *GB28181Plugin) getGroupChannels(groupId int32) ([]*pb.GroupChannel, er
 		InGroup     bool   `gorm:"column:in_group"`
 	}
 
-	// 构建查询
+	// 构建优化后的查询
 	query := gb.DB.Table(groupsChannelTable+" AS gc").
 		Select(`
 			gc.id AS id,
 			gc.channel_id AS channel_id,
 			gc.device_id AS device_id,
-			dc.name AS channel_name,
-			d.name AS device_name,
-			dc.status AS status,
+			ch.name AS channel_name,
+			dev.name AS device_name,
+			ch.status AS status,
 			true AS in_group
 		`).
-		Joins("LEFT JOIN "+deviceChannelTable+" AS dc ON gc.channel_id = dc.channel_id").
-		Joins("LEFT JOIN "+deviceTable+" AS d ON gc.device_id = d.device_id").
+		Joins("LEFT JOIN "+deviceChannelTable+" AS ch ON gc.device_id = ch.device_id AND gc.channel_id = ch.channel_id").
+		Joins("LEFT JOIN "+deviceTable+" AS dev ON ch.device_id = dev.device_id").
 		Where("gc.group_id = ?", groupId)
 
 	var results []Result
@@ -2085,7 +2102,7 @@ func (gb *GB28181Plugin) getGroupChannels(groupId int32) ([]*pb.GroupChannel, er
 	for _, result := range results {
 		channelInfo := &pb.GroupChannel{
 			Id:          int32(result.ID),
-			GroupId:     groupId,
+			GroupId:     groupId, // 使用函数参数 groupId
 			ChannelId:   result.ChannelID,
 			DeviceId:    result.DeviceID,
 			ChannelName: result.ChannelName,
@@ -2468,12 +2485,9 @@ func (gb *GB28181Plugin) PlaybackPause(ctx context.Context, req *pb.PlaybackPaus
 		resp.Message = fmt.Sprintf("发送暂停请求失败: %v", err)
 		return resp, nil
 	}
-	gb.Server.Streams.Call(func() error {
-		if s, ok := gb.Server.Streams.Get(req.StreamPath); ok {
-			s.Pause()
-		}
-		return nil
-	})
+	if s, ok := gb.Server.Streams.SafeGet(req.StreamPath); ok {
+		s.Pause()
+	}
 	gb.Info("暂停回放",
 		"streampath", req.StreamPath)
 
@@ -2522,12 +2536,9 @@ func (gb *GB28181Plugin) PlaybackResume(ctx context.Context, req *pb.PlaybackRes
 		resp.Message = fmt.Sprintf("发送恢复请求失败: %v", err)
 		return resp, nil
 	}
-	gb.Server.Streams.Call(func() error {
-		if s, ok := gb.Server.Streams.Get(req.StreamPath); ok {
-			s.Resume()
-		}
-		return nil
-	})
+	if s, ok := gb.Server.Streams.SafeGet(req.StreamPath); ok {
+		s.Resume()
+	}
 	gb.Info("恢复回放",
 		"streampath", req.StreamPath)
 
@@ -2595,14 +2606,11 @@ func (gb *GB28181Plugin) PlaybackSpeed(ctx context.Context, req *pb.PlaybackSpee
 	// 发送请求
 	_, err := dialog.session.TransactionRequest(ctx, request)
 
-	gb.Server.Streams.Call(func() error {
-		if s, ok := gb.Server.Streams.Get(req.StreamPath); ok {
-			s.Speed = float64(req.Speed)
-			s.Scale = float64(req.Speed)
-			s.Info("set stream speed", "speed", req.Speed)
-		}
-		return nil
-	})
+	if s, ok := gb.Server.Streams.SafeGet(req.StreamPath); ok {
+		s.Speed = float64(req.Speed)
+		s.Scale = float64(req.Speed)
+		s.Info("set stream speed", "speed", req.Speed)
+	}
 	if err != nil {
 		resp.Code = 500
 		resp.Message = fmt.Sprintf("发送倍速请求失败: %v", err)
@@ -2826,62 +2834,54 @@ func (gb *GB28181Plugin) RemoveDevice(ctx context.Context, req *pb.RemoveDeviceR
 		return resp, nil
 	}
 
-	// 检查数据库连接
-	if gb.DB == nil {
-		resp.Code = 500
-		resp.Message = "数据库未初始化"
-		return resp, nil
-	}
-
-	// 开启事务
-	tx := gb.DB.Begin()
-
-	// 先从数据库中查找设备
-	var dbDevice Device
-	if err := tx.Where(&Device{DeviceId: req.Id}).First(&dbDevice).Error; err != nil {
-		tx.Rollback()
-		resp.Code = 404
-		resp.Message = fmt.Sprintf("设备不存在: %v", err)
-		return resp, nil
-	}
-
 	// 使用数据库中的 DeviceId 从内存中查找设备
-	if device, ok := gb.devices.Get(dbDevice.DeviceId); ok {
+	if device, ok := gb.devices.Get(req.Id); ok {
+		device.DeletedAt = gorm.DeletedAt{Time: time.Now(), Valid: true}
+		device.channels.Range(func(channel *Channel) bool {
+			channel.DeletedAt = gorm.DeletedAt{Time: time.Now(), Valid: true}
+			return true
+		})
 		// 停止设备相关任务
 		device.Stop(fmt.Errorf("device removed"))
 		device.WaitStopped()
 		// device.Stop() 会调用 Dispose()，其中已包含从 gb.devices 中移除设备的逻辑
+
+		// 开启数据库事务
+		tx := gb.DB.Begin()
+		if tx.Error != nil {
+			resp.Code = 500
+			resp.Message = "开启事务失败"
+			return resp, tx.Error
+		}
+
+		// 删除设备
+		if err := tx.Delete(&Device{DeviceId: req.Id}).Error; err != nil {
+			tx.Rollback()
+			resp.Code = 500
+			resp.Message = "删除设备失败"
+			return resp, err
+		}
+
+		// 删除设备关联的通道
+		if err := tx.Where("device_id = ?", req.Id).Delete(&gb28181.DeviceChannel{}).Error; err != nil {
+			tx.Rollback()
+			resp.Code = 500
+			resp.Message = "删除设备通道失败"
+			return resp, err
+		}
+
+		// 提交事务
+		if err := tx.Commit().Error; err != nil {
+			tx.Rollback()
+			resp.Code = 500
+			resp.Message = "提交事务失败"
+			return resp, err
+		}
+
+		resp.Code = 200
+		resp.Message = "设备删除成功"
 	}
 
-	// 删除设备关联的所有通道
-	if err := tx.Where(&gb28181.DeviceChannel{DeviceID: dbDevice.DeviceId}).Delete(&gb28181.DeviceChannel{}).Error; err != nil {
-		tx.Rollback()
-		resp.Code = 500
-		resp.Message = fmt.Sprintf("删除设备通道失败: %v", err)
-		return resp, nil
-	}
-
-	// 删除设备
-	if err := tx.Delete(&dbDevice).Error; err != nil {
-		tx.Rollback()
-		resp.Code = 500
-		resp.Message = fmt.Sprintf("删除设备失败: %v", err)
-		return resp, nil
-	}
-
-	// 提交事务
-	if err := tx.Commit().Error; err != nil {
-		resp.Code = 500
-		resp.Message = fmt.Sprintf("提交事务失败: %v", err)
-		return resp, nil
-	}
-
-	gb.Info("删除设备成功",
-		"deviceId", dbDevice.DeviceId,
-		"deviceName", dbDevice.Name)
-
-	resp.Code = 0
-	resp.Message = "success"
 	return resp, nil
 }
 

plugin/gb28181/device.go

@@ -92,18 +92,16 @@ func (d *Device) TableName() string {
 
 func (d *Device) Dispose() {
 	if d.plugin.DB != nil {
-		d.plugin.DB.Save(d)
 		if d.channels.Length > 0 {
 			d.channels.Range(func(channel *Channel) bool {
 				d.plugin.DB.Save(channel.DeviceChannel)
 				//d.plugin.DB.Model(&gb28181.DeviceChannel{}).Where("device_id = ? AND device_db_id = ?", channel.DeviceId, d.ID).Updates(channel.DeviceChannel)
 				return true
 			})
-		} else {
-			// 如果没有通道，则直接更新通道状态为 OFF
-			d.plugin.DB.Model(&gb28181.DeviceChannel{}).Where("device_id = ?", d.ID).Update("status", "OFF")
 		}
+		d.plugin.DB.Save(d)
 	}
+	d.plugin.devices.RemoveByKey(d.DeviceId)
 }
 
 func (d *Device) GetKey() string {
@@ -140,7 +138,7 @@ func (r *CatalogRequest) IsComplete(channelsLength int) bool {
 }
 
 func (d *Device) onMessage(req *sip.Request, tx sip.ServerTransaction, msg *gb28181.Message) (err error) {
-	d.plugin.Debug("into onMessage,deviceid is ", d.DeviceId)
+	d.plugin.Trace("into onMessage,deviceid is ", d.DeviceId)
 	source := req.Source()
 	hostname, portStr, _ := net.SplitHostPort(source)
 	port, _ := strconv.Atoi(portStr)
@@ -161,7 +159,7 @@ func (d *Device) onMessage(req *sip.Request, tx sip.ServerTransaction, msg *gb28
 	case "Keepalive":
 		d.KeepaliveInterval = int(time.Since(d.KeepaliveTime).Seconds())
 		d.KeepaliveTime = time.Now()
-		d.Debug("into keeplive,deviceid is ", d.DeviceId, "d.KeepaliveTime is", d.KeepaliveTime)
+		d.Trace("into keeplive,deviceid is ", d.DeviceId, "d.KeepaliveTime is", d.KeepaliveTime)
 		if d.plugin.DB != nil {
 			if err := d.plugin.DB.Model(d).Updates(map[string]interface{}{
 				"keepalive_interval": d.KeepaliveInterval,
@@ -191,7 +189,7 @@ func (d *Device) onMessage(req *sip.Request, tx sip.ServerTransaction, msg *gb28
 		if d.plugin.DB != nil {
 			// 如果是第一个响应，先清空现有通道
 			if isFirst {
-				d.Debug("清空现有通道", "deviceId", d.DeviceId)
+				d.Trace("清空现有通道", "deviceId", d.DeviceId)
 				if err := d.plugin.DB.Where("device_id = ?", d.DeviceId).Delete(&gb28181.DeviceChannel{}).Error; err != nil {
 					d.Error("删除通道失败", "error", err, "deviceId", d.DeviceId)
 				}
@@ -215,7 +213,7 @@ func (d *Device) onMessage(req *sip.Request, tx sip.ServerTransaction, msg *gb28
 			// 更新当前设备的通道数
 			d.ChannelCount = msg.SumNum
 			d.UpdateTime = time.Now()
-			d.Debug("save channel", "deviceid", d.DeviceId, "channels count", d.channels.Length)
+			d.Trace("save channel", "deviceid", d.DeviceId, "channels count", d.channels.Length)
 			if err := d.plugin.DB.Model(d).Updates(map[string]interface{}{
 				"channel_count": d.ChannelCount,
 				"update_time":   d.UpdateTime,
@@ -325,7 +323,10 @@ func (d *Device) onMessage(req *sip.Request, tx sip.ServerTransaction, msg *gb28
 		}
 	case "DeviceInfo":
 		// 主设备信息
-		d.Name = msg.DeviceName
+		d.Info("DeviceInfo message", "body", req.Body(), "d.Name", d.Name, "d.DeviceId", d.DeviceId, "msg.DeviceName", msg.DeviceName)
+		if d.Name == "" && msg.DeviceName != "" {
+			d.Name = msg.DeviceName
+		}
 		d.Manufacturer = msg.Manufacturer
 		d.Model = msg.Model
 		d.Firmware = msg.Firmware
@@ -400,12 +401,12 @@ func (d *Device) onMessage(req *sip.Request, tx sip.ServerTransaction, msg *gb28
 
 func (d *Device) send(req *sip.Request) (*sip.Response, error) {
 	d.SN++
-	d.Debug("send", "req", req.String())
+	d.Trace("send", "req", req.String())
 	return d.client.Do(context.Background(), req)
 }
 
 func (d *Device) Go() (err error) {
-	d.Debug("into device.Go,deviceid is ", d.DeviceId)
+	d.Trace("into device.Go,deviceid is ", d.DeviceId)
 	var response *sip.Response
 
 	// 初始化catalogReqs
@@ -423,7 +424,7 @@ func (d *Device) Go() (err error) {
 	if err != nil {
 		d.Error("catalog", "err", err)
 	} else {
-		d.Debug("catalog", "response", response.String())
+		d.Trace("catalog", "response", response.String())
 	}
 
 	// 创建并启动目录订阅任务
@@ -450,7 +451,7 @@ func (d *Device) Go() (err error) {
 		select {
 		case <-d.Done():
 		case <-keepLiveTick.C:
-			d.Debug("keepLiveTick,deviceid is", d.DeviceId, "d.KeepaliveTime is ", d.KeepaliveTime)
+			d.Trace("keepLiveTick,deviceid is", d.DeviceId, "d.KeepaliveTime is ", d.KeepaliveTime)
 			if timeDiff := time.Since(d.KeepaliveTime); timeDiff > time.Duration(3*keepaliveSeconds)*time.Second {
 				d.Online = false
 				d.Status = DeviceOfflineStatus
@@ -471,7 +472,7 @@ func (d *Device) Go() (err error) {
 			if err != nil {
 				d.Error("catalog", "err", err)
 			} else {
-				d.Debug("catalogTick", "response", response.String())
+				d.Trace("catalogTick", "response", response.String())
 			}
 			//case event := <-d.eventChan:
 			//	d.Debug("eventChan", "event", event)

plugin/gb28181/dialog.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"math/rand"
+	"net"
 	"net/url"
 	"strconv"
 	"strings"
@@ -44,7 +45,11 @@ type Dialog struct {
 }
 
 func (d *Dialog) GetCallID() string {
-	return d.session.InviteRequest.CallID().Value()
+	if d.session != nil && d.session.InviteRequest != nil && d.session.InviteRequest.CallID() != nil {
+		return d.session.InviteRequest.CallID().Value()
+	} else {
+		return ""
+	}
 }
 
 func (d *Dialog) GetPullJob() *m7s.PullJob {
@@ -95,15 +100,20 @@ func (d *Dialog) Start() (err error) {
 
 	d.gb.dialogs.Set(d)
 	//defer d.gb.dialogs.Remove(d)
-	if d.gb.MediaPort.Valid() {
-		select {
-		case d.MediaPort = <-d.gb.tcpPorts:
-		default:
-			return fmt.Errorf("no available tcp port")
-		}
+	if d.gb.tcpPort > 0 {
+		d.MediaPort = d.gb.tcpPort
 	} else {
-		d.MediaPort = d.gb.MediaPort[0]
+		if d.gb.MediaPort.Valid() {
+			select {
+			case d.MediaPort = <-d.gb.tcpPorts:
+			default:
+				return fmt.Errorf("no available tcp port")
+			}
+		} else {
+			d.MediaPort = d.gb.MediaPort[0]
+		}
 	}
+
 	ssrc := d.CreateSSRC(d.gb.Serial)
 	d.Info("MediaIp is ", device.MediaIp)
 
@@ -115,9 +125,9 @@ func (d *Dialog) Start() (err error) {
 	}
 
 	// 非直播模式下添加u行，保持在s=和c=之间
-	//if !d.IsLive() {
-	sdpInfo = append(sdpInfo, fmt.Sprintf("u=%s:0", channelId))
-	//}
+	if !d.IsLive() {
+		sdpInfo = append(sdpInfo, fmt.Sprintf("u=%s:0", channelId))
+	}
 
 	// 添加c行
 	sdpInfo = append(sdpInfo, "c=IN IP4 "+device.MediaIp)
@@ -126,7 +136,7 @@ func (d *Dialog) Start() (err error) {
 	if !d.IsLive() {
 		startTime, endTime, err := util.TimeRangeQueryParse(url.Values{"start": []string{d.start}, "end": []string{d.end}})
 		if err != nil {
-			d.Stop(errors.New("parse end time error"))
+			return errors.New("parse end time error")
 		}
 		sdpInfo = append(sdpInfo, fmt.Sprintf("t=%d %d", startTime.Unix(), endTime.Unix()))
 	} else {
@@ -145,10 +155,12 @@ func (d *Dialog) Start() (err error) {
 	}
 
 	sdpInfo = append(sdpInfo, mediaLine)
+
 	sdpInfo = append(sdpInfo, "a=recvonly")
 	if d.stream != "" {
 		sdpInfo = append(sdpInfo, "a="+d.stream)
 	}
+	sdpInfo = append(sdpInfo, "a=rtpmap:96 PS/90000")
 
 	//根据传输模式添加 setup 和 connection 属性
 	switch strings.ToUpper(device.StreamMode) {
@@ -163,14 +175,13 @@ func (d *Dialog) Start() (err error) {
 			"a=connection:new",
 		)
 	case "UDP":
-		d.Stop(errors.New("do not support udp mode"))
+		return errors.New("do not support udp mode")
 	default:
 		sdpInfo = append(sdpInfo,
 			"a=setup:passive",
 			"a=connection:new",
 		)
 	}
-	sdpInfo = append(sdpInfo, "a=rtpmap:96 PS/90000")
 
 	// 添加 SSRC
 	sdpInfo = append(sdpInfo, fmt.Sprintf("y=%s", ssrc))
@@ -238,21 +249,20 @@ func (d *Dialog) Start() (err error) {
 	//}
 	// 最后添加Content-Length头部
 	if err != nil {
-		d.gb.Error("invite error", err)
+		return errors.New("dialog invite error" + err.Error())
 	}
 	return
 }
 
 func (d *Dialog) Run() (err error) {
-	d.Channel.Info("before WaitAnswer")
+	d.gb.Info("before WaitAnswer")
 	err = d.session.WaitAnswer(d.gb, sipgo.AnswerOptions{})
-	d.Channel.Info("after WaitAnswer")
-	d.gb.Error(" WaitAnswer error", err)
+	d.gb.Info("after WaitAnswer")
 	if err != nil {
-		return
+		return errors.New("wait answer error" + err.Error())
 	}
 	inviteResponseBody := string(d.session.InviteResponse.Body())
-	d.Channel.Info("inviteResponse", "body", inviteResponseBody)
+	d.gb.Info("inviteResponse", "body", inviteResponseBody)
 	ds := strings.Split(inviteResponseBody, "\r\n")
 	for _, l := range ds {
 		if ls := strings.Split(l, "="); len(ls) > 1 {
@@ -262,7 +272,7 @@ func (d *Dialog) Run() (err error) {
 					if _ssrc, err := strconv.ParseInt(ls[1], 10, 0); err == nil {
 						d.SSRC = uint32(_ssrc)
 					} else {
-						d.gb.Error("read invite response y ", "err", err)
+						return errors.New("read invite respose y error" + err.Error())
 					}
 				}
 			case "c":
@@ -295,10 +305,26 @@ func (d *Dialog) Run() (err error) {
 	if d.StreamMode == "TCP-ACTIVE" {
 		pub.Receiver.ListenAddr = fmt.Sprintf("%s:%d", d.targetIP, d.targetPort)
 	} else {
+		if d.gb.tcpPort > 0 {
+			d.Info("into single port mode,use gb.tcpPort", d.gb.tcpPort)
+			if d.gb.netListener != nil {
+				d.Info("use gb.netListener", d.gb.netListener.Addr())
+				pub.Receiver.Listener = d.gb.netListener
+			} else {
+				d.Info("listen tcp4", fmt.Sprintf(":%d", d.gb.tcpPort))
+				pub.Receiver.Listener, _ = net.Listen("tcp4", fmt.Sprintf(":%d", d.gb.tcpPort))
+				d.gb.netListener = pub.Receiver.Listener
+			}
+			pub.Receiver.SSRC = d.SSRC
+		}
 		pub.Receiver.ListenAddr = fmt.Sprintf(":%d", d.MediaPort)
 	}
 	pub.Receiver.StreamMode = d.StreamMode
 	d.AddTask(&pub.Receiver)
+	startResult := pub.Receiver.WaitStarted()
+	if startResult != nil {
+		return fmt.Errorf("pub.Receiver.WaitStarted %s", startResult)
+	}
 	pub.Demux()
 	return
 }
@@ -308,7 +334,11 @@ func (d *Dialog) GetKey() uint32 {
 }
 
 func (d *Dialog) Dispose() {
-	d.gb.tcpPorts <- d.MediaPort
+	if d.gb.tcpPort == 0 {
+		// 如果没有设置tcp端口，则将MediaPort设置为0，表示不再使用
+		d.gb.tcpPorts <- d.MediaPort
+	}
+	d.Info("dialog dispose", "ssrc", d.SSRC, "mediaPort", d.MediaPort, "streamMode", d.StreamMode, "deviceId", d.Channel.DeviceID, "channelId", d.Channel.ChannelID)
 	if d.session != nil {
 		err := d.session.Bye(d)
 		if err != nil {

plugin/gb28181/index.go

@@ -3,6 +3,7 @@ package plugin_gb28181pro
 import (
 	"errors"
 	"fmt"
+	"net"
 	"net/http"
 	"os"
 	"slices"
@@ -11,6 +12,8 @@ import (
 	"sync"
 	"time"
 
+	"m7s.live/v5/pkg"
+
 	"github.com/emiago/sipgo"
 	"github.com/emiago/sipgo/sip"
 	"github.com/rs/zerolog"
@@ -38,7 +41,7 @@ type GB28181Plugin struct {
 	pb.UnimplementedApiServer
 	m7s.Plugin
 	Serial         string `default:"34020000002000000001" desc:"sip 服务 id"` //sip 服务器 id, 默认 34020000002000000001
-	Realm          string `default:"3402000000" desc:"sip 服务域"`             //sip 服务器域，默认 3402000000
+	Realm          string `default:"3402000000" desc:"sip 服务域"`            //sip 服务器域，默认 3402000000
 	Password       string
 	Sip            SipConfig
 	MediaPort      util.Range[uint16] `default:"10001-20000" desc:"媒体端口范围"` //媒体端口范围
@@ -52,12 +55,14 @@ type GB28181Plugin struct {
 	forwardDialogs util.Collection[uint32, *ForwardDialog]
 	platforms      util.Collection[string, *Platform]
 	tcpPorts       chan uint16
+	tcpPort        uint16
 	sipPorts       []int
 	SipIP          string `desc:"sip发送命令的IP，一般是本地IP，多网卡时需要配置正确的IP"`
 	MediaIP        string `desc:"流媒体IP，用于接收流"`
 	deviceManager  task.Manager[string, *DeviceRegisterQueueTask]
 	Platforms      []*gb28181.PlatformModel
 	channels       util.Collection[string, *gb28181.DeviceChannel]
+	netListener    net.Listener
 }
 
 var _ = m7s.InstallPlugin[GB28181Plugin](m7s.PluginMeta{
@@ -72,6 +77,18 @@ var _ = m7s.InstallPlugin[GB28181Plugin](m7s.PluginMeta{
 	NewPullProxy: NewPullProxy,
 })
 
+func (gb *GB28181Plugin) Dispose() {
+	if gb.netListener != nil {
+		gb.Info("gb28181 plugin dispose")
+		err := gb.netListener.Close()
+		if err != nil {
+			gb.Error("Close netListener error", "error", err)
+		} else {
+			gb.Info("netListener closed")
+		}
+	}
+}
+
 func init() {
 	sip.SIPDebug = true
 }
@@ -129,6 +146,9 @@ func (gb *GB28181Plugin) initDatabase() error {
 }
 
 func (gb *GB28181Plugin) OnInit() (err error) {
+	if gb.DB == nil {
+		return pkg.ErrNoDB
+	}
 	gb.Info("GB28181 initing", gb.Platforms)
 	gb.AddTask(&gb.deviceManager)
 	logger := zerolog.New(os.Stdout)
@@ -147,8 +167,16 @@ func (gb *GB28181Plugin) OnInit() (err error) {
 		if gb.MediaPort.Valid() {
 			gb.SetDescription("tcp", fmt.Sprintf("%d-%d", gb.MediaPort[0], gb.MediaPort[1]))
 			gb.tcpPorts = make(chan uint16, gb.MediaPort.Size())
-			for i := range gb.MediaPort.Size() {
-				gb.tcpPorts <- gb.MediaPort[0] + i
+			if gb.MediaPort.Size() == 0 {
+				gb.tcpPort = gb.MediaPort[0]
+				gb.netListener, _ = net.Listen("tcp4", fmt.Sprintf(":%d", gb.tcpPort))
+			} else if gb.MediaPort.Size() == 1 {
+				gb.tcpPort = gb.MediaPort[0] + 1
+				gb.netListener, _ = net.Listen("tcp4", fmt.Sprintf(":%d", gb.tcpPort))
+			} else {
+				for i := range gb.MediaPort.Size() {
+					gb.tcpPorts <- gb.MediaPort[0] + i
+				}
 			}
 		} else {
 			gb.SetDescription("tcp", fmt.Sprintf("%d", gb.MediaPort[0]))
@@ -277,7 +305,7 @@ func (gb *GB28181Plugin) checkDeviceExpire() (err error) {
 				gb.devices.Set(device)
 			})
 			device.channels.OnAdd(func(c *Channel) {
-				if absDevice, ok := gb.Server.PullProxies.Find(func(absDevice m7s.IPullProxy) bool {
+				if absDevice, ok := gb.Server.PullProxies.SafeFind(func(absDevice m7s.IPullProxy) bool {
 					conf := absDevice.GetConfig()
 					return conf.Type == "gb28181" && conf.URL == fmt.Sprintf("%s/%s", device.DeviceId, c.ChannelID)
 				}); ok {
@@ -377,45 +405,48 @@ func (gb *GB28181Plugin) checkPlatform() {
 
 	// 遍历所有平台进行初始化和注册
 	for _, platformModel := range platformModels {
-		// 创建Platform实例
-		platform := NewPlatform(platformModel, gb, true)
+		if platformModel.Enable {
 
-		if platformModel.PlatformChannels != nil && len(platformModel.PlatformChannels) > 0 {
-			for i := range platformModel.PlatformChannels {
-				channelDbId := platformModel.PlatformChannels[i].ChannelDBID
-				if channelDbId != "" {
-					if channel, ok := gb.channels.Get(channelDbId); ok {
-						platform.channels.Set(channel)
-					}
-				}
-			}
-		} else {
-			// 查询通道列表
-			var channels []gb28181.DeviceChannel
-			if gb.DB != nil {
-				if err := gb.DB.Table("gb28181_channel gc").
-					Select(`gc.*`).
-					Joins("left join gb28181_platform_channel gpc on gc.id=gpc.channel_db_id").
-					Where("gpc.platform_server_gb_id = ? and gc.status='ON'", platformModel.ServerGBID).
-					Find(&channels).Error; err != nil {
-					gb.Error("<UNK>", "error", err.Error())
-				}
-				if channels != nil && len(channels) > 0 {
-					for i := range channels {
-						if channel, ok := gb.channels.Get(channels[i].ID); ok {
+			// 创建Platform实例
+			platform := NewPlatform(platformModel, gb, true)
+
+			if platformModel.PlatformChannels != nil && len(platformModel.PlatformChannels) > 0 {
+				for i := range platformModel.PlatformChannels {
+					channelDbId := platformModel.PlatformChannels[i].ChannelDBID
+					if channelDbId != "" {
+						if channel, ok := gb.channels.Get(channelDbId); ok {
 							platform.channels.Set(channel)
 						}
 					}
 				}
+			} else {
+				// 查询通道列表
+				var channels []gb28181.DeviceChannel
+				if gb.DB != nil {
+					if err := gb.DB.Table("gb28181_channel gc").
+						Select(`gc.*`).
+						Joins("left join gb28181_platform_channel gpc on gc.id=gpc.channel_db_id").
+						Where("gpc.platform_server_gb_id = ? and gc.status='ON'", platformModel.ServerGBID).
+						Find(&channels).Error; err != nil {
+						gb.Error("<UNK>", "error", err.Error())
+					}
+					if channels != nil && len(channels) > 0 {
+						for i := range channels {
+							if channel, ok := gb.channels.Get(channels[i].ID); ok {
+								platform.channels.Set(channel)
+							}
+						}
+					}
+				}
 			}
+			//go platform.Unregister()
+			//if err != nil {
+			//	 gb.Error("unregister err ", err)
+			//}
+			// 添加到任务系统
+			gb.AddTask(platform)
+			gb.Info("平台初始化完成", "ID", platformModel.ServerGBID, "Name", platformModel.Name)
 		}
-		//go platform.Unregister()
-		//if err != nil {
-		//	 gb.Error("unregister err ", err)
-		//}
-		// 添加到任务系统
-		gb.AddTask(platform)
-		gb.Info("平台初始化完成", "ID", platformModel.ServerGBID, "Name", platformModel.Name)
 	}
 }
 
@@ -494,7 +525,6 @@ func (gb *GB28181Plugin) OnMessage(req *sip.Request, tx sip.ServerTransaction) {
 		}
 	}
 
-	gb.Debug("00000000000001,deviceid is ", id)
 	// 如果设备和平台都存在，通过源地址判断真实来源
 	if d != nil && d.Online && p != nil {
 		source := req.Source()
@@ -506,7 +536,6 @@ func (gb *GB28181Plugin) OnMessage(req *sip.Request, tx sip.ServerTransaction) {
 			d = nil
 		}
 	}
-	gb.Debug("00000000000002,deviceid is ", id)
 
 	// 如果既不是设备也不是平台，返回404
 	if (d == nil && p == nil) || (d != nil && !d.Online) {
@@ -519,7 +548,6 @@ func (gb *GB28181Plugin) OnMessage(req *sip.Request, tx sip.ServerTransaction) {
 		gb.Debug("after on message respond")
 		return
 	}
-	gb.Debug("00000000000003,deviceid is ", id)
 
 	// 根据来源调用不同的处理方法
 	if d != nil && d.Online {

plugin/gb28181/pkg/transceiver.go

@@ -44,8 +44,9 @@ type Receiver struct {
 	psAudio    PSAudio
 	RTPReader  *rtp2.TCP
 	ListenAddr string
-	listener   net.Listener
+	Listener   net.Listener
 	StreamMode string // 数据流传输模式（UDP:udp传输/TCP-ACTIVE：tcp主动模式/TCP-PASSIVE：tcp被动模式）
+	SSRC       uint32 // RTP SSRC
 }
 
 func NewPSPublisher(puber *m7s.Publisher) *PSPublisher {
@@ -147,9 +148,19 @@ func (p *Receiver) ReadRTP(rtp util.Buffer) (err error) {
 		p.Error("unmarshal error", "err", err)
 		return
 	}
+
+	// 如果设置了SSRC过滤，只处理匹配的SSRC
+	if p.SSRC != 0 && p.SSRC != p.Packet.SSRC {
+		p.Info("into single port mode, ssrc mismatch", "expected", p.SSRC, "actual", p.Packet.SSRC)
+		if p.TraceEnabled() {
+			p.Trace("rtp ssrc mismatch, skip", "expected", p.SSRC, "actual", p.Packet.SSRC)
+		}
+		return nil
+	}
+
 	if lastSeq == 0 || p.SequenceNumber == lastSeq+1 {
 		if p.TraceEnabled() {
-			p.Trace("rtp", "len", rtp.Len(), "seq", p.SequenceNumber, "payloadType", p.PayloadType, "ssrc", p.SSRC)
+			p.Trace("rtp", "len", rtp.Len(), "seq", p.SequenceNumber, "payloadType", p.PayloadType, "ssrc", p.Packet.SSRC)
 		}
 		copyData := make([]byte, len(p.Payload))
 		copy(copyData, p.Payload)
@@ -172,18 +183,24 @@ func (p *Receiver) Start() (err error) {
 		return nil
 	}
 	// TCP被动模式
-	p.listener, err = net.Listen("tcp4", p.ListenAddr)
-	if err != nil {
-		p.Error("start listen", "err", err)
-		return errors.New("start listen,err" + err.Error())
+	if p.Listener == nil {
+		p.Info("start new listener", "addr", p.ListenAddr)
+		p.Listener, err = net.Listen("tcp4", p.ListenAddr)
+		if err != nil {
+			p.Error("start listen", "err", err)
+			return errors.New("start listen,err" + err.Error())
+		}
 	}
 	p.Info("start listen", "addr", p.ListenAddr)
 	return
 }
 
 func (p *Receiver) Dispose() {
-	if p.listener != nil {
-		p.listener.Close()
+	if p.SSRC == 0 {
+		p.Info("into multiport mode ,close listener ", p.SSRC)
+		if p.Listener != nil {
+			p.Listener.Close()
+		}
 	}
 	if p.RTPReader != nil {
 		p.RTPReader.Close()
@@ -216,7 +233,7 @@ func (p *Receiver) Go() error {
 	}
 	// TCP被动模式
 	p.Info("start accept")
-	conn, err := p.listener.Accept()
+	conn, err := p.Listener.Accept()
 	if err != nil {
 		p.Error("accept", "err", err)
 		return err

plugin/gb28181/platform.go

@@ -335,6 +335,8 @@ func (p *Platform) Register(isUnregister bool) error {
 		newReq := req.Clone()
 		newReq.RemoveHeader("Via") // 必须由传输层重新生成
 		newReq.AppendHeader(sip.NewHeader("Authorization", cred.String()))
+		newReq.CSeq().SeqNo = uint32(p.SN) // 更新CSeq序号
+		p.SN++
 
 		// 发送认证请求
 		tx, err = p.Client.TransactionRequest(p.ctx, newReq, sipgo.ClientRequestAddVia)

plugin/gb28181/registerhandler.go

@@ -36,6 +36,14 @@ type registerHandlerTask struct {
 	tx  sip.ServerTransaction
 }
 
+// getDevicePassword 获取设备密码
+func (task *registerHandlerTask) getDevicePassword(device *Device) string {
+	if device != nil && device.Password != "" {
+		return device.Password
+	}
+	return task.gb.Password
+}
+
 func (task *registerHandlerTask) Run() (err error) {
 	var password string
 	var device *Device
@@ -47,23 +55,25 @@ func (task *registerHandlerTask) Run() (err error) {
 	}
 	isUnregister := false
 	deviceid := from.Address.User
-	if devicetmp, ok := task.gb.devices.Get(deviceid); ok {
-		device = devicetmp
+
+	if existingDevice, exists := task.gb.devices.Get(deviceid); exists && existingDevice != nil {
+		device = existingDevice
 		recover = true
 	} else {
-		if err := task.gb.DB.First(&device, Device{DeviceId: deviceid}).Error; err == nil {
-			if device.Password != "" {
-				password = device.Password
-			} else if task.gb.Password != "" {
-				password = task.gb.Password
-			}
-		} else {
-			if !errors.Is(err, gorm.ErrRecordNotFound) {
-				task.gb.Error("OnRegister", "error", err)
+		// 尝试从数据库加载设备信息
+		device = &Device{DeviceId: deviceid}
+		if task.gb.DB != nil {
+			if err := task.gb.DB.First(device, Device{DeviceId: deviceid}).Error; err != nil {
+				if !errors.Is(err, gorm.ErrRecordNotFound) {
+					task.gb.Error("OnRegister", "error", err)
+				}
 			}
 		}
 	}
 
+	// 获取设备密码
+	password = task.getDevicePassword(device)
+
 	exp := task.req.GetHeader("Expires")
 	if exp == nil {
 		task.gb.Error("OnRegister", "error", "no expires")
@@ -136,7 +146,7 @@ func (task *registerHandlerTask) Run() (err error) {
 			Method:   "REGISTER",
 			URI:      cred.URI,
 			Username: deviceid,
-			Password: task.gb.Password,
+			Password: password,
 			Cnonce:   cred.Cnonce,
 			Count:    int(cred.Nc),
 		}
@@ -222,11 +232,14 @@ func (task *registerHandlerTask) Run() (err error) {
 			device.Status = DeviceOnlineStatus
 			task.RecoverDevice(device, task.req)
 		} else {
-			device := &Device{
-				DeviceId: deviceid,
+			var newDevice *Device
+			if device == nil {
+				newDevice = &Device{DeviceId: deviceid}
+			} else {
+				newDevice = device
 			}
 			task.gb.Info("into StoreDevice", "deviceId", from)
-			task.StoreDevice(deviceid, task.req, device)
+			task.StoreDevice(deviceid, task.req, newDevice)
 		}
 	}
 	task.gb.Info("registerHandlerTask start end", "deviceid", deviceid, "expires", expSec, "isUnregister", isUnregister)
@@ -438,7 +451,7 @@ func (task *registerHandlerTask) StoreDevice(deviceid string, req *sip.Request,
 	d.OnStart(func() {
 		task.gb.devices.Set(d)
 		d.channels.OnAdd(func(c *Channel) {
-			if absDevice, ok := task.gb.Server.PullProxies.Find(func(absDevice m7s.IPullProxy) bool {
+			if absDevice, ok := task.gb.Server.PullProxies.SafeFind(func(absDevice m7s.IPullProxy) bool {
 				conf := absDevice.GetConfig()
 				return conf.Type == "gb28181" && conf.URL == fmt.Sprintf("%s/%s", d.DeviceId, c.ChannelID)
 			}); ok {

plugin/hls/download.go

@@ -0,0 +1,422 @@
+package plugin_hls
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	m7s "m7s.live/v5"
+	"m7s.live/v5/pkg"
+	"m7s.live/v5/pkg/codec"
+	"m7s.live/v5/pkg/util"
+	hls "m7s.live/v5/plugin/hls/pkg"
+	mpegts "m7s.live/v5/plugin/hls/pkg/ts"
+	mp4 "m7s.live/v5/plugin/mp4/pkg"
+)
+
+// requestParams 包含请求解析后的参数
+type requestParams struct {
+	streamPath string
+	startTime  time.Time
+	endTime    time.Time
+	timeRange  time.Duration
+}
+
+// fileInfo 包含文件信息
+type fileInfo struct {
+	filePath        string
+	startTime       time.Time
+	endTime         time.Time
+	startOffsetTime time.Duration
+	recordType      string // "ts", "mp4", "fmp4"
+}
+
+// parseRequestParams 解析请求参数
+func (plugin *HLSPlugin) parseRequestParams(r *http.Request) (*requestParams, error) {
+	// 从URL路径中提取流路径，去除前缀 "/download/" 和后缀 ".ts"
+	streamPath := strings.TrimSuffix(strings.TrimPrefix(r.URL.Path, "/download/"), ".ts")
+
+	// 解析URL查询参数中的时间范围（start和end参数）
+	startTime, endTime, err := util.TimeRangeQueryParse(r.URL.Query())
+	if err != nil {
+		return nil, err
+	}
+
+	return &requestParams{
+		streamPath: streamPath,
+		startTime:  startTime,
+		endTime:    endTime,
+		timeRange:  endTime.Sub(startTime),
+	}, nil
+}
+
+// queryRecordStreams 从数据库查询录像记录
+func (plugin *HLSPlugin) queryRecordStreams(params *requestParams) ([]m7s.RecordStream, error) {
+	// 检查数据库是否可用
+	if plugin.DB == nil {
+		return nil, fmt.Errorf("database not available")
+	}
+
+	var recordStreams []m7s.RecordStream
+
+	// 首先查询HLS记录 (ts)
+	query := plugin.DB.Model(&m7s.RecordStream{}).Where("stream_path = ? AND type = ?", params.streamPath, "hls")
+
+	// 添加时间范围查询条件
+	if !params.startTime.IsZero() && !params.endTime.IsZero() {
+		query = query.Where("(start_time <= ? AND end_time >= ?) OR (start_time >= ? AND start_time <= ?)",
+			params.endTime, params.startTime, params.startTime, params.endTime)
+	}
+
+	err := query.Order("start_time ASC").Find(&recordStreams).Error
+	if err != nil {
+		return nil, err
+	}
+
+	// 如果没有找到HLS记录，尝试查询MP4记录
+	if len(recordStreams) == 0 {
+		query = plugin.DB.Model(&m7s.RecordStream{}).Where("stream_path = ? AND type IN (?)", params.streamPath, []string{"mp4", "fmp4"})
+
+		if !params.startTime.IsZero() && !params.endTime.IsZero() {
+			query = query.Where("(start_time <= ? AND end_time >= ?) OR (start_time >= ? AND start_time <= ?)",
+				params.endTime, params.startTime, params.startTime, params.endTime)
+		}
+
+		err = query.Order("start_time ASC").Find(&recordStreams).Error
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return recordStreams, nil
+}
+
+// buildFileInfoList 构建文件信息列表
+func (plugin *HLSPlugin) buildFileInfoList(recordStreams []m7s.RecordStream, startTime, endTime time.Time) ([]*fileInfo, bool) {
+	var fileInfoList []*fileInfo
+	var found bool
+
+	for _, record := range recordStreams {
+		// 检查文件是否存在
+		if !util.Exist(record.FilePath) {
+			plugin.Warn("Record file not found", "filePath", record.FilePath)
+			continue
+		}
+
+		var startOffsetTime time.Duration
+		recordStartTime := record.StartTime
+		recordEndTime := record.EndTime
+
+		// 计算文件内的偏移时间
+		if startTime.After(recordStartTime) {
+			startOffsetTime = startTime.Sub(recordStartTime)
+		}
+
+		// 检查是否在时间范围内
+		if recordEndTime.Before(startTime) || recordStartTime.After(endTime) {
+			continue
+		}
+
+		fileInfoList = append(fileInfoList, &fileInfo{
+			filePath:        record.FilePath,
+			startTime:       recordStartTime,
+			endTime:         recordEndTime,
+			startOffsetTime: startOffsetTime,
+			recordType:      record.Type,
+		})
+
+		found = true
+	}
+
+	return fileInfoList, found
+}
+
+// hasOnlyMp4Records 检查是否只有MP4记录
+func (plugin *HLSPlugin) hasOnlyMp4Records(fileInfoList []*fileInfo) bool {
+	if len(fileInfoList) == 0 {
+		return false
+	}
+
+	for _, info := range fileInfoList {
+		if info.recordType == "hls" {
+			return false
+		}
+	}
+	return true
+}
+
+// filterTsFiles 过滤HLS TS文件
+func (plugin *HLSPlugin) filterTsFiles(fileInfoList []*fileInfo) []*fileInfo {
+	var filteredList []*fileInfo
+
+	for _, info := range fileInfoList {
+		if info.recordType == "hls" {
+			filteredList = append(filteredList, info)
+		}
+	}
+
+	plugin.Debug("TS files filtered", "original", len(fileInfoList), "filtered", len(filteredList))
+	return filteredList
+}
+
+// filterMp4Files 过滤MP4文件
+func (plugin *HLSPlugin) filterMp4Files(fileInfoList []*fileInfo) []*fileInfo {
+	var filteredList []*fileInfo
+
+	for _, info := range fileInfoList {
+		if info.recordType == "mp4" || info.recordType == "fmp4" {
+			filteredList = append(filteredList, info)
+		}
+	}
+
+	plugin.Debug("MP4 files filtered", "original", len(fileInfoList), "filtered", len(filteredList))
+	return filteredList
+}
+
+// processMp4ToTs 将MP4记录转换为TS输出
+func (plugin *HLSPlugin) processMp4ToTs(w http.ResponseWriter, r *http.Request, fileInfoList []*fileInfo, params *requestParams) {
+	plugin.Info("Converting MP4 records to TS", "count", len(fileInfoList))
+
+	// 设置HTTP响应头
+	w.Header().Set("Content-Type", "video/mp2t")
+	w.Header().Set("Content-Disposition", "attachment")
+
+	// 创建MP4流列表
+	var mp4Streams []m7s.RecordStream
+	for _, info := range fileInfoList {
+		plugin.Debug("Processing MP4 file", "path", info.filePath, "startTime", info.startTime, "endTime", info.endTime)
+		mp4Streams = append(mp4Streams, m7s.RecordStream{
+			FilePath:  info.filePath,
+			StartTime: info.startTime,
+			EndTime:   info.endTime,
+			Type:      info.recordType,
+		})
+	}
+
+	// 创建DemuxerConverterRange进行MP4解复用和转换
+	demuxer := &mp4.DemuxerConverterRange[*pkg.ADTS, *pkg.AnnexB]{
+		DemuxerRange: mp4.DemuxerRange{
+			StartTime: params.startTime,
+			EndTime:   params.endTime,
+			Streams:   mp4Streams,
+			Logger:    plugin.Logger.With("demuxer", "mp4_Ts"),
+		},
+	}
+
+	// 创建TS编码器状态
+	tsWriter := &hls.TsInMemory{}
+	hasWritten := false
+	// 写入PMT头的辅助函数
+	writePMTHeader := func() {
+		if !hasWritten {
+			var audio, video codec.FourCC
+			if demuxer.AudioTrack != nil && demuxer.AudioTrack.ICodecCtx != nil {
+				audio = demuxer.AudioTrack.ICodecCtx.FourCC()
+			}
+			if demuxer.VideoTrack != nil && demuxer.VideoTrack.ICodecCtx != nil {
+				video = demuxer.VideoTrack.ICodecCtx.FourCC()
+			}
+			tsWriter.WritePMTPacket(audio, video)
+			hasWritten = true
+		}
+	}
+	// 创建音频帧结构
+	audioFrame := mpegts.MpegtsPESFrame{
+		Pid: mpegts.PID_AUDIO,
+	}
+	// 创建视频帧结构
+	videoFrame := mpegts.MpegtsPESFrame{
+		Pid: mpegts.PID_VIDEO,
+	}
+	// 执行解复用和转换
+	err := demuxer.Demux(r.Context(),
+		func(audio *pkg.ADTS) error {
+			writePMTHeader()
+			// 写入音频帧
+			return tsWriter.WriteAudioFrame(audio, &audioFrame)
+		}, func(video *pkg.AnnexB) error {
+			writePMTHeader()
+			videoFrame.IsKeyFrame = demuxer.VideoTrack.Value.IDR
+			// 写入视频帧
+			return tsWriter.WriteVideoFrame(video, &videoFrame)
+		})
+
+	if err != nil {
+		plugin.Error("MP4 to TS conversion failed", "err", err)
+		if !hasWritten {
+			http.Error(w, "Conversion failed", http.StatusInternalServerError)
+		}
+		return
+	}
+
+	// 将所有累积的 TsInMemory 内容写入到响应
+	w.WriteHeader(http.StatusOK)
+	_, err = tsWriter.WriteTo(w)
+	if err != nil {
+		plugin.Error("Failed to write TS data to response", "error", err)
+		return
+	}
+
+	plugin.Info("MP4 to TS conversion completed")
+}
+
+// processTsFiles 处理原生TS文件拼接
+func (plugin *HLSPlugin) processTsFiles(w http.ResponseWriter, r *http.Request, fileInfoList []*fileInfo, params *requestParams) {
+	plugin.Info("Processing TS files", "count", len(fileInfoList))
+
+	// 设置HTTP响应头
+	w.Header().Set("Content-Type", "video/mp2t")
+	w.Header().Set("Content-Disposition", "attachment")
+
+	var writer io.Writer = w
+	var totalSize uint64
+
+	// 第一次遍历：计算总大小
+	for _, info := range fileInfoList {
+		if r.Context().Err() != nil {
+			return
+		}
+
+		fileInfo, err := os.Stat(info.filePath)
+		if err != nil {
+			plugin.Error("Failed to stat file", "path", info.filePath, "err", err)
+			continue
+		}
+		totalSize += uint64(fileInfo.Size())
+	}
+
+	// 设置内容长度
+	w.Header().Set("Content-Length", strconv.FormatUint(totalSize, 10))
+	w.WriteHeader(http.StatusOK)
+
+	// 第二次遍历：写入数据
+	for i, info := range fileInfoList {
+		if r.Context().Err() != nil {
+			return
+		}
+
+		plugin.Debug("Processing TS file", "path", info.filePath)
+		file, err := os.Open(info.filePath)
+		if err != nil {
+			plugin.Error("Failed to open file", "path", info.filePath, "err", err)
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		reader := bufio.NewReader(file)
+
+		if i == 0 {
+			// 第一个文件，直接拷贝
+			_, err = io.Copy(writer, reader)
+		} else {
+			// 后续文件，跳过PAT/PMT包，只拷贝媒体数据
+			err = plugin.copyTsFileSkipHeaders(writer, reader)
+		}
+
+		file.Close()
+
+		if err != nil {
+			plugin.Error("Failed to copy file", "path", info.filePath, "err", err)
+			return
+		}
+	}
+
+	plugin.Info("TS download completed")
+}
+
+// copyTsFileSkipHeaders 拷贝TS文件，跳过PAT/PMT包
+func (plugin *HLSPlugin) copyTsFileSkipHeaders(writer io.Writer, reader *bufio.Reader) error {
+	buffer := make([]byte, mpegts.TS_PACKET_SIZE)
+
+	for {
+		n, err := io.ReadFull(reader, buffer)
+		if err != nil {
+			if err == io.EOF || err == io.ErrUnexpectedEOF {
+				break
+			}
+			return err
+		}
+
+		if n != mpegts.TS_PACKET_SIZE {
+			continue
+		}
+
+		// 检查同步字节
+		if buffer[0] != 0x47 {
+			continue
+		}
+
+		// 提取PID
+		pid := uint16(buffer[1]&0x1f)<<8 | uint16(buffer[2])
+
+		// 跳过PAT(PID=0)和PMT(PID=256)包
+		if pid == mpegts.PID_PAT || pid == mpegts.PID_PMT {
+			continue
+		}
+
+		// 写入媒体数据包
+		_, err = writer.Write(buffer)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// download 下载处理函数
+func (plugin *HLSPlugin) download(w http.ResponseWriter, r *http.Request) {
+	// 解析请求参数
+	params, err := plugin.parseRequestParams(r)
+	if err != nil {
+		plugin.Error("Failed to parse request params", "err", err)
+		http.Error(w, "Invalid parameters", http.StatusBadRequest)
+		return
+	}
+
+	plugin.Info("TS download request", "streamPath", params.streamPath, "timeRange", params.timeRange)
+
+	// 查询录像记录
+	recordStreams, err := plugin.queryRecordStreams(params)
+	if err != nil {
+		plugin.Error("Failed to query record streams", "err", err)
+		http.Error(w, "Database error", http.StatusInternalServerError)
+		return
+	}
+
+	if len(recordStreams) == 0 {
+		plugin.Warn("No records found", "streamPath", params.streamPath)
+		http.Error(w, "No records found", http.StatusNotFound)
+		return
+	}
+
+	// 构建文件信息列表
+	fileInfoList, found := plugin.buildFileInfoList(recordStreams, params.startTime, params.endTime)
+	if !found {
+		plugin.Warn("No valid files found", "streamPath", params.streamPath)
+		http.Error(w, "No valid files found", http.StatusNotFound)
+		return
+	}
+
+	// 检查文件类型并处理
+	if plugin.hasOnlyMp4Records(fileInfoList) {
+		// 只有MP4记录，转换为TS
+		mp4Files := plugin.filterMp4Files(fileInfoList)
+		plugin.processMp4ToTs(w, r, mp4Files, params)
+	} else {
+		// 有TS记录，优先使用TS文件
+		tsFiles := plugin.filterTsFiles(fileInfoList)
+		if len(tsFiles) > 0 {
+			plugin.processTsFiles(w, r, tsFiles, params)
+		} else {
+			// 没有TS文件，使用MP4转换
+			mp4Files := plugin.filterMp4Files(fileInfoList)
+			plugin.processMp4ToTs(w, r, mp4Files, params)
+		}
+	}
+}

plugin/hls/index.go

@@ -59,6 +59,7 @@ func (p *HLSPlugin) OnInit() (err error) {
 func (p *HLSPlugin) RegisterHandler() map[string]http.HandlerFunc {
 	return map[string]http.HandlerFunc{
 		"/vod/{streamPath...}":              p.vod,
+		"/download/{streamPath...}":         p.download,
 		"/api/record/start/{streamPath...}": p.API_record_start,
 		"/api/record/stop/{id}":             p.API_record_stop,
 	}
@@ -73,6 +74,9 @@ func (config *HLSPlugin) vod(w http.ResponseWriter, r *http.Request) {
 	}
 	query := r.URL.Query()
 	fileName := query.Get("streamPath")
+	if fileName == "" {
+		fileName = r.PathValue("streamPath")
+	}
 	waitTimeout, err := time.ParseDuration(query.Get("timeout"))
 	if err == nil {
 		config.Debug("request", "fileName", fileName, "timeout", waitTimeout)
@@ -104,9 +108,8 @@ func (config *HLSPlugin) vod(w http.ResponseWriter, r *http.Request) {
 					playlist.Init()
 
 					for _, record := range records {
-						duration := record.EndTime.Sub(record.StartTime).Seconds()
 						playlist.WriteInf(hls.PlaylistInf{
-							Duration: duration,
+							Duration: float64(record.Duration) / 1000,
 							URL:      fmt.Sprintf("/mp4/download/%s.fmp4?id=%d", streamPath, record.ID),
 							Title:    record.StartTime.Format(time.RFC3339),
 						})
@@ -114,6 +117,25 @@ func (config *HLSPlugin) vod(w http.ResponseWriter, r *http.Request) {
 					plBuffer.WriteString("#EXT-X-ENDLIST\n")
 					w.Write(plBuffer)
 					return
+				} else if recordType == "ts" {
+					playlist := hls.Playlist{
+						Version:        3,
+						Sequence:       0,
+						Targetduration: 10,
+					}
+					var plBuffer util.Buffer
+					playlist.Writer = &plBuffer
+					playlist.Init()
+					for i := startTime; i.Before(endTime); i = i.Add(10 * time.Second) {
+						playlist.WriteInf(hls.PlaylistInf{
+							Duration: 10,
+							URL:      fmt.Sprintf("/hls/download/%s.ts?start=%d&end=%d", streamPath, i.Unix(), i.Add(10*time.Second).Unix()),
+							Title:    i.Format(time.RFC3339),
+						})
+					}
+					plBuffer.WriteString("#EXT-X-ENDLIST\n")
+					w.Write(plBuffer)
+					return
 				}
 				query := `stream_path = ? AND type = ? AND start_time IS NOT NULL AND end_time IS NOT NULL AND ? <= end_time AND ? >= start_time`
 				config.DB.Where(query, streamPath, recordType, startTime, endTime).Find(&records)
@@ -128,9 +150,8 @@ func (config *HLSPlugin) vod(w http.ResponseWriter, r *http.Request) {
 					playlist.Init()
 
 					for _, record := range records {
-						duration := record.EndTime.Sub(record.StartTime).Seconds()
 						playlist.WriteInf(hls.PlaylistInf{
-							Duration: duration,
+							Duration: float64(record.Duration) / 1000,
 							URL:      record.FilePath,
 						})
 					}
@@ -274,7 +295,7 @@ func (config *HLSPlugin) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 			}
 		}
 	} else {
-		http.ServeFileFS(w, r, zipReader, strings.TrimPrefix(r.URL.Path, "/hls.js"))
+		http.ServeFileFS(w, r, zipReader, r.URL.Path)
 	}
 }
 

plugin/hls/pkg/record.go

@@ -2,16 +2,13 @@ package hls
 
 import (
 	"fmt"
-	"os"
 	"path/filepath"
 	"time"
 
-	"gorm.io/gorm"
 	"m7s.live/v5"
 	"m7s.live/v5/pkg"
 	"m7s.live/v5/pkg/codec"
 	"m7s.live/v5/pkg/config"
-	"m7s.live/v5/pkg/task"
 	"m7s.live/v5/pkg/util"
 	mpegts "m7s.live/v5/plugin/hls/pkg/ts"
 )
@@ -22,7 +19,6 @@ func NewRecorder(conf config.Record) m7s.IRecorder {
 
 type Recorder struct {
 	m7s.DefaultRecorder
-	stream       m7s.RecordStream
 	ts           *TsInFile
 	pesAudio     *mpegts.MpegtsPESFrame
 	pesVideo     *mpegts.MpegtsPESFrame
@@ -39,81 +35,12 @@ var CustomFileName = func(job *m7s.RecordJob) string {
 }
 
 func (r *Recorder) createStream(start time.Time) (err error) {
-	recordJob := &r.RecordJob
-	sub := recordJob.Subscriber
-	r.stream = m7s.RecordStream{
-		StartTime:      start,
-		StreamPath:     sub.StreamPath,
-		FilePath:       CustomFileName(&r.RecordJob),
-		EventId:        recordJob.EventId,
-		EventDesc:      recordJob.EventDesc,
-		EventName:      recordJob.EventName,
-		EventLevel:     recordJob.EventLevel,
-		BeforeDuration: recordJob.BeforeDuration,
-		AfterDuration:  recordJob.AfterDuration,
-		Mode:           recordJob.Mode,
-		Type:           "hls",
-	}
-	dir := filepath.Dir(r.stream.FilePath)
-	dir = filepath.Clean(dir)
-	if err = os.MkdirAll(dir, 0755); err != nil {
-		r.Error("create directory failed", "err", err, "dir", dir)
-		return
-	}
-	if sub.Publisher.HasAudioTrack() {
-		r.stream.AudioCodec = sub.Publisher.AudioTrack.ICodecCtx.String()
-	}
-	if sub.Publisher.HasVideoTrack() {
-		r.stream.VideoCodec = sub.Publisher.VideoTrack.ICodecCtx.String()
-	}
-	if recordJob.Plugin.DB != nil {
-		recordJob.Plugin.DB.Save(&r.stream)
-	}
-	return
-}
-
-type eventRecordCheck struct {
-	task.Task
-	DB         *gorm.DB
-	streamPath string
-}
-
-func (t *eventRecordCheck) Run() (err error) {
-	var eventRecordStreams []m7s.RecordStream
-	queryRecord := m7s.RecordStream{
-		EventLevel: m7s.EventLevelHigh,
-		Mode:       m7s.RecordModeEvent,
-		Type:       "hls",
-	}
-	t.DB.Where(&queryRecord).Find(&eventRecordStreams, "stream_path=?", t.streamPath) //搜索事件录像，且为重要事件（无法自动删除）
-	if len(eventRecordStreams) > 0 {
-		for _, recordStream := range eventRecordStreams {
-			var unimportantEventRecordStreams []m7s.RecordStream
-			queryRecord.EventLevel = m7s.EventLevelLow
-			query := `(start_time BETWEEN ? AND ?)
-							OR (end_time BETWEEN ? AND ?) 
-							OR (? BETWEEN start_time AND end_time) 
-							OR (? BETWEEN start_time AND end_time) AND stream_path=? `
-			t.DB.Where(&queryRecord).Where(query, recordStream.StartTime, recordStream.EndTime, recordStream.StartTime, recordStream.EndTime, recordStream.StartTime, recordStream.EndTime, recordStream.StreamPath).Find(&unimportantEventRecordStreams)
-			if len(unimportantEventRecordStreams) > 0 {
-				for _, unimportantEventRecordStream := range unimportantEventRecordStreams {
-					unimportantEventRecordStream.EventLevel = m7s.EventLevelHigh
-					t.DB.Save(&unimportantEventRecordStream)
-				}
-			}
-		}
-	}
-	return
+	r.RecordJob.RecConf.Type = "ts"
+	return r.CreateStream(start, CustomFileName)
 }
 
 func (r *Recorder) writeTailer(end time.Time) {
-	if r.stream.EndTime.After(r.stream.StartTime) {
-		return
-	}
-	r.stream.EndTime = end
-	if r.RecordJob.Plugin.DB != nil {
-		r.RecordJob.Plugin.DB.Save(&r.stream)
-	}
+	r.WriteTail(end, nil)
 }
 
 func (r *Recorder) Dispose() {
@@ -131,9 +58,9 @@ func (r *Recorder) createNewTs() {
 		r.ts.Close()
 	}
 	var err error
-	r.ts, err = NewTsInFile(r.stream.FilePath)
+	r.ts, err = NewTsInFile(r.Event.FilePath)
 	if err != nil {
-		r.Error("create ts file failed", "err", err, "path", r.stream.FilePath)
+		r.Error("create ts file failed", "err", err, "path", r.Event.FilePath)
 		return
 	}
 	if oldPMT.Len() > 0 {
@@ -141,7 +68,7 @@ func (r *Recorder) createNewTs() {
 	}
 }
 
-func (r *Recorder) writeSegment(ts time.Duration) (err error) {
+func (r *Recorder) writeSegment(ts time.Duration, writeTime time.Time) (err error) {
 	if dur := ts - r.lastTs; dur >= r.RecordJob.RecConf.Fragment || r.lastTs == 0 {
 		if dur == ts && r.lastTs == 0 { //时间戳不对的情况，首个默认为2s
 			dur = time.Duration(2) * time.Second
@@ -155,10 +82,10 @@ func (r *Recorder) writeSegment(ts time.Duration) (err error) {
 		}
 
 		// 结束当前片段的记录
-		r.writeTailer(time.Now())
+		r.writeTailer(writeTime)
 
 		// 创建新的数据库记录
-		err = r.createStream(time.Now())
+		err = r.createStream(writeTime)
 		if err != nil {
 			return
 		}
@@ -175,10 +102,6 @@ func (r *Recorder) Run() (err error) {
 	ctx := &r.RecordJob
 	suber := ctx.Subscriber
 	startTime := time.Now()
-	if ctx.BeforeDuration > 0 {
-		startTime = startTime.Add(-ctx.BeforeDuration)
-	}
-
 	// 创建第一个片段记录
 	if err = r.createStream(startTime); err != nil {
 		return
@@ -212,7 +135,7 @@ func (r *Recorder) ProcessADTS(audio *pkg.ADTS) (err error) {
 
 func (r *Recorder) ProcessAnnexB(video *pkg.AnnexB) (err error) {
 	if r.RecordJob.Subscriber.VideoReader.Value.IDR {
-		if err = r.writeSegment(video.GetTimestamp()); err != nil {
+		if err = r.writeSegment(video.GetTimestamp(), r.RecordJob.Subscriber.VideoReader.Value.WriteTime); err != nil {
 			return
 		}
 	}

plugin/hls/pkg/ts/mpegts_psi.go

@@ -1,9 +1,11 @@
 package mpegts
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
 	"io"
+
 	"m7s.live/v5/pkg/util"
 )
 
@@ -179,50 +181,56 @@ func WritePSI(w io.Writer, pt uint32, psi MpegTsPSI, data []byte) (err error) {
 		return
 	}
 
-	cw := &util.Crc32Writer{W: w, Crc32: 0xffffffff}
+	// 使用buffer收集所有需要计算CRC32的数据
+	bw := &bytes.Buffer{}
 
 	// table id(8)
-	if err = util.WriteUint8ToByte(cw, tableId); err != nil {
+	if err = util.WriteUint8ToByte(bw, tableId); err != nil {
 		return
 	}
 
 	// sectionSyntaxIndicator(1) + zero(1)  + reserved1(2) + sectionLength(12)
 	// sectionLength 前两个字节固定为00
 	// 1 0 11 sectionLength
-	if err = util.WriteUint16ToByte(cw, sectionSyntaxIndicatorAndSectionLength, true); err != nil {
+	if err = util.WriteUint16ToByte(bw, sectionSyntaxIndicatorAndSectionLength, true); err != nil {
 		return
 	}
 
 	// PAT TransportStreamID(16) or PMT ProgramNumber(16)
-	if err = util.WriteUint16ToByte(cw, transportStreamIdOrProgramNumber, true); err != nil {
+	if err = util.WriteUint16ToByte(bw, transportStreamIdOrProgramNumber, true); err != nil {
 		return
 	}
 
 	// reserved2(2) + versionNumber(5) + currentNextIndicator(1)
 	// 0x3 << 6 -> 1100 0000
 	// 0x3 << 6  | 1 -> 1100 0001
-	if err = util.WriteUint8ToByte(cw, versionNumberAndCurrentNextIndicator); err != nil {
+	if err = util.WriteUint8ToByte(bw, versionNumberAndCurrentNextIndicator); err != nil {
 		return
 	}
 
 	// sectionNumber(8)
-	if err = util.WriteUint8ToByte(cw, sectionNumber); err != nil {
+	if err = util.WriteUint8ToByte(bw, sectionNumber); err != nil {
 		return
 	}
 
 	// lastSectionNumber(8)
-	if err = util.WriteUint8ToByte(cw, lastSectionNumber); err != nil {
+	if err = util.WriteUint8ToByte(bw, lastSectionNumber); err != nil {
 		return
 	}
 
 	// data
-	if _, err = cw.Write(data); err != nil {
+	if _, err = bw.Write(data); err != nil {
 		return
 	}
 
-	// crc32
-	crc32 := util.BigLittleSwap(uint(cw.Crc32))
-	if err = util.WriteUint32ToByte(cw, uint32(crc32), true); err != nil {
+	// 写入PSI数据
+	if _, err = w.Write(bw.Bytes()); err != nil {
+		return
+	}
+
+	// 使用MPEG-TS CRC32算法计算CRC32
+	crc32 := GetCRC32(bw.Bytes())
+	if err = util.WriteUint32ToByte(w, crc32, true); err != nil {
 		return
 	}
 

plugin/mp4/README_CN.md

@@ -77,3 +77,100 @@ mp4:
 
 此时如果有人订阅了 vod/test/123 流，那么就会从数据库中查询streamPath 为 `live/test` 录制文件，并且根据拉流参数中的 start 参数筛选录制文件。
 此时 123 就是某个订阅者的唯一标识。
+
+
+## 拼装逻辑
+```mermaid
+sequenceDiagram
+    participant Client
+    participant Handler as download()
+    participant DB as Database
+    participant Muxer as MP4Muxer
+    participant File1 as RecordFile1
+    participant File2 as RecordFile2
+    participant FileN as RecordFileN
+    participant Writer as ResponseWriter
+
+    Client->>Handler: GET /download?start=xxx&end=xxx
+    Handler->>Handler: 解析时间范围参数
+    Handler->>DB: 查询时间范围内的录制文件
+    DB-->>Handler: 返回 streams[]
+    
+    Handler->>Muxer: NewMuxer(flag)
+    Handler->>Muxer: CreateFTYPBox()
+    
+    Note over Handler: 初始化变量：lastTs, tsOffset, parts[], audioTrack, videoTrack
+    
+    loop 遍历每个录制文件
+        Handler->>File1: os.Open(stream.FilePath)
+        File1-->>Handler: file handle
+        Handler->>File1: NewDemuxer(file)
+        Handler->>File1: demuxer.Demux()
+        File1-->>Handler: 解析完成
+        
+        alt 第一个文件
+            Handler->>Handler: 处理开始时间偏移
+            loop 处理每个track
+                Handler->>Muxer: AddTrack(track.Cid)
+                Muxer-->>Handler: 新轨道
+            end
+        end
+        
+        Note over Handler: 设置 tsOffset = lastTs
+        
+        loop 处理每个样本 (RangeSample)
+            alt 最后一个文件 && 超出结束时间
+                Handler->>Handler: break (跳出循环)
+            else
+                Handler->>Handler: 创建 ContentPart
+                Handler->>Handler: 计算调整后时间戳
+                
+                alt flag == 0 (常规MP4)
+                    Handler->>Handler: 调整样本偏移量
+                    Handler->>Muxer: AddSampleEntry(fixSample)
+                else flag == FLAG_FRAGMENT (分片MP4)
+                    Handler->>File1: 读取样本数据
+                    File1-->>Handler: sample.Data
+                    Handler->>Muxer: CreateFlagment(track, sample)
+                    Muxer-->>Handler: moof, mdat boxes
+                    Handler->>Handler: 添加到 part.boxies
+                end
+                
+                Handler->>Handler: 更新 lastTs
+            end
+        end
+        
+        Handler->>Handler: 添加 part 到 parts[]
+        Handler->>File1: Close()
+    end
+    
+    alt flag == 0 (常规MP4模式)
+        Handler->>Muxer: MakeMoov()
+        Muxer-->>Handler: moov box
+        Handler->>Handler: 计算总大小
+        Handler->>Writer: Set Content-Length header
+        Handler->>Writer: 调整样本偏移量
+        Handler->>Muxer: CreateBaseBox(MDAT)
+        Muxer-->>Handler: mdat box
+        
+        Handler->>Writer: WriteTo(ftyp, moov, free, mdat header)
+        
+        loop 写入所有内容片段
+            Handler->>Handler: part.Seek(part.Start)
+            Handler->>Writer: io.CopyN(writer, part.File, part.Size)
+            Handler->>Handler: part.Close()
+        end
+        
+    else flag == FLAG_FRAGMENT (分片MP4模式)
+        Handler->>Handler: 组装所有 children boxes
+        Handler->>Handler: 计算总大小
+        Handler->>Writer: Set Content-Length header
+        Handler->>Writer: WriteTo(所有boxes)
+        
+        loop 关闭所有文件
+            Handler->>Handler: part.Close()
+        end
+    end
+    
+    Handler-->>Client: MP4文件流
+```

plugin/mp4/api.go

@@ -165,7 +165,6 @@ func (p *MP4Plugin) download(w http.ResponseWriter, r *http.Request) {
 
 	// 构建查询条件，查找指定时间范围内的录制记录
 	queryRecord := m7s.RecordStream{
-		Mode: m7s.RecordModeAuto,
 		Type: "mp4",
 	}
 	p.DB.Where(&queryRecord).Find(&streams, "end_time>? AND start_time<? AND stream_path=?", startTime, endTime, streamPath)
@@ -458,26 +457,34 @@ func (p *MP4Plugin) StartRecord(ctx context.Context, req *mp4pb.ReqStartRecord)
 		filePath = req.FilePath
 	}
 	res = &mp4pb.ResponseStartRecord{}
-	p.Server.Records.Call(func() error {
-		_, recordExists = p.Server.Records.Find(func(job *m7s.RecordJob) bool {
-			return job.StreamPath == req.StreamPath && job.RecConf.FilePath == req.FilePath
-		})
-		return nil
+	_, recordExists = p.Server.Records.SafeFind(func(job *m7s.RecordJob) bool {
+		return job.StreamPath == req.StreamPath && job.RecConf.FilePath == req.FilePath
 	})
 	if recordExists {
 		err = pkg.ErrRecordExists
 		return
 	}
+
+	recordConf := config.Record{
+		Append:   false,
+		Fragment: fragment,
+		FilePath: filePath,
+	}
 	if stream, ok := p.Server.Streams.SafeGet(req.StreamPath); ok {
-		recordConf := config.Record{
-			Append:   false,
-			Fragment: fragment,
-			FilePath: filePath,
-		}
 		job := p.Record(stream, recordConf, nil)
 		res.Data = uint64(uintptr(unsafe.Pointer(job.GetTask())))
 	} else {
-		err = pkg.ErrNotFound
+		sub, err := p.Subscribe(ctx, req.StreamPath)
+		if err == nil && sub != nil {
+			if stream, ok := p.Server.Streams.SafeGet(req.StreamPath); ok {
+				job := p.Record(stream, recordConf, nil)
+				res.Data = uint64(uintptr(unsafe.Pointer(job.GetTask())))
+			} else {
+				err = pkg.ErrNotFound
+			}
+		} else {
+			err = pkg.ErrNotFound
+		}
 	}
 	return
 }
@@ -485,19 +492,16 @@ func (p *MP4Plugin) StartRecord(ctx context.Context, req *mp4pb.ReqStartRecord)
 func (p *MP4Plugin) StopRecord(ctx context.Context, req *mp4pb.ReqStopRecord) (res *mp4pb.ResponseStopRecord, err error) {
 	res = &mp4pb.ResponseStopRecord{}
 	var recordJob *m7s.RecordJob
-	p.Server.Records.Call(func() error {
-		recordJob, _ = p.Server.Records.Find(func(job *m7s.RecordJob) bool {
-			return job.StreamPath == req.StreamPath
-		})
-		if recordJob != nil {
-			t := recordJob.GetTask()
-			if t != nil {
-				res.Data = uint64(uintptr(unsafe.Pointer(t)))
-				t.Stop(task.ErrStopByUser)
-			}
-		}
-		return nil
+	recordJob, _ = p.Server.Records.SafeFind(func(job *m7s.RecordJob) bool {
+		return job.StreamPath == req.StreamPath
 	})
+	if recordJob != nil {
+		t := recordJob.GetTask()
+		if t != nil {
+			res.Data = uint64(uintptr(unsafe.Pointer(t)))
+			t.Stop(task.ErrStopByUser)
+		}
+	}
 	return
 }
 
@@ -519,11 +523,8 @@ func (p *MP4Plugin) EventStart(ctx context.Context, req *mp4pb.ReqEventRecord) (
 	}
 	//recorder := p.Meta.Recorder(config.Record{})
 	var tmpJob *m7s.RecordJob
-	p.Server.Records.Call(func() error {
-		tmpJob, _ = p.Server.Records.Find(func(job *m7s.RecordJob) bool {
-			return job.StreamPath == req.StreamPath
-		})
-		return nil
+	tmpJob, _ = p.Server.Records.SafeFind(func(job *m7s.RecordJob) bool {
+		return job.StreamPath == req.StreamPath
 	})
 	if tmpJob == nil { //为空表示没有正在进行的录制，也就是没有自动录像，则进行正常的事件录像
 		if stream, ok := p.Server.Streams.SafeGet(req.StreamPath); ok {
@@ -531,49 +532,51 @@ func (p *MP4Plugin) EventStart(ctx context.Context, req *mp4pb.ReqEventRecord) (
 				Append:   false,
 				Fragment: 0,
 				FilePath: filepath.Join(p.EventRecordFilePath, stream.StreamPath, time.Now().Local().Format("2006-01-02-15-04-05")),
+				Mode:     config.RecordModeEvent,
+				Event: &config.RecordEvent{
+					EventId:        req.EventId,
+					EventLevel:     req.EventLevel,
+					EventName:      req.EventName,
+					EventDesc:      req.EventDesc,
+					BeforeDuration: uint32(beforeDuration / time.Millisecond),
+					AfterDuration:  uint32(afterDuration / time.Millisecond),
+				},
 			}
 			//recordJob := recorder.GetRecordJob()
 			var subconfig config.Subscribe
 			defaults.SetDefaults(&subconfig)
 			subconfig.BufferTime = beforeDuration
-			recordJob := p.Record(stream, recordConf, &subconfig)
-			recordJob.EventId = req.EventId
-			recordJob.EventLevel = req.EventLevel
-			recordJob.EventName = req.EventName
-			recordJob.EventDesc = req.EventDesc
-			recordJob.AfterDuration = afterDuration
-			recordJob.BeforeDuration = beforeDuration
-			recordJob.Mode = m7s.RecordModeEvent
+			p.Record(stream, recordConf, &subconfig)
 		}
 	} else {
-		if tmpJob.AfterDuration != 0 { //当前有事件录像正在录制，则更新该录像的结束时间
-			tmpJob.AfterDuration = time.Duration(tmpJob.Subscriber.VideoReader.AbsTime)*time.Millisecond + afterDuration
+		if tmpJob.Event != nil { //当前有事件录像正在录制，则更新该录像的结束时间
+			tmpJob.Event.AfterDuration = tmpJob.Subscriber.VideoReader.AbsTime + uint32(afterDuration/time.Millisecond)
+			if p.DB != nil {
+				p.DB.Save(&tmpJob.Event)
+			}
 		} else { //当前有自动录像正在录制，则生成事件录像的记录，而不去生成事件录像的文件
-			recordStream := &m7s.RecordStream{
-				StreamPath:     req.StreamPath,
+			newEvent := &config.RecordEvent{
 				EventId:        req.EventId,
 				EventLevel:     req.EventLevel,
-				EventDesc:      req.EventDesc,
 				EventName:      req.EventName,
-				Mode:           m7s.RecordModeEvent,
-				BeforeDuration: beforeDuration,
-				AfterDuration:  afterDuration,
-				Type:           "mp4",
+				EventDesc:      req.EventDesc,
+				BeforeDuration: uint32(beforeDuration / time.Millisecond),
+				AfterDuration:  uint32(afterDuration / time.Millisecond),
 			}
-			now := time.Now()
-			startTime := now.Add(-beforeDuration)
-			endTime := now.Add(afterDuration)
-			recordStream.StartTime = startTime
-			recordStream.EndTime = endTime
 			if p.DB != nil {
-				p.DB.Save(&recordStream)
+				p.DB.Save(&m7s.EventRecordStream{
+					RecordEvent: newEvent,
+					RecordStream: m7s.RecordStream{
+						StreamPath: req.StreamPath,
+					},
+				})
 			}
 		}
 	}
 	return res, err
 }
 
-func (p *MP4Plugin) List(ctx context.Context, req *mp4pb.ReqRecordList) (resp *pb.ResponseList, err error) {
+func (p *MP4Plugin) List(ctx context.Context, req *mp4pb.ReqRecordList) (resp *pb.RecordResponseList, err error) {
 	globalReq := &pb.ReqRecordList{
 		StreamPath: req.StreamPath,
 		Range:      req.Range,
@@ -581,7 +584,6 @@ func (p *MP4Plugin) List(ctx context.Context, req *mp4pb.ReqRecordList) (resp *p
 		End:        req.End,
 		PageNum:    req.PageNum,
 		PageSize:   req.PageSize,
-		Mode:       req.Mode,
 		Type:       "mp4",
 		EventLevel: req.EventLevel,
 	}

plugin/mp4/api_extract.go

@@ -0,0 +1,874 @@
+/**
+ * @file 文件名.h
+ * @brief MP4 文件查询提取功能,GOP提取新的MP4，片段提取图片等，已验证测试H264,H265
+ * @author erroot
+ * @date 250614
+ * @version 1.0.0
+ */
+
+package plugin_mp4
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	m7s "m7s.live/v5"
+	"m7s.live/v5/pkg"
+	"m7s.live/v5/pkg/util"
+	mp4 "m7s.live/v5/plugin/mp4/pkg"
+	"m7s.live/v5/plugin/mp4/pkg/box"
+)
+
+// bytes2hexStr 将字节数组前n个字节转为16进制字符串
+// data: 原始字节数组
+// length: 需要转换的字节数（超过实际长度时自动截断）
+func Bytes2HexStr(data []byte, length int) string {
+	if length > len(data) {
+		length = len(data)
+	}
+
+	var builder strings.Builder
+	for i := 0; i < length; i++ {
+		if i > 0 {
+			builder.WriteString(" ")
+		}
+		builder.WriteString(fmt.Sprintf("%02X", data[i]))
+	}
+	return builder.String()
+}
+
+/*
+提取压缩视频（快放视频）
+
+njtv/glgc.mp4?
+start=1748620153000&
+end=1748620453000&
+outputPath=/opt/njtv/1748620153000.mp4
+gopSeconds=1&
+gopInterval=1&
+
+FLAG_FRAGMENT  暂时不支持没有调试
+
+假设原生帧率25fps   GOP = 50 frame
+时间范围: endTime-startTime = 300s   = 7500 frame =   150 GOP
+gopSeconds=0.2   6 frame
+gopInterval=10
+提取结果15 gop,   90 frame ,  90/25 = 3.6 s
+
+反过推算 要求 5范围分钟 压缩到15s 播放完
+当gopSeconds=0.1， 推算 gopInterval=1
+当gopSeconds=0.2， 推算 gopInterval=2
+*/
+func (p *MP4Plugin) extractCompressedVideo(streamPath string, startTime, endTime time.Time, writer io.Writer, gopSeconds float64, gopInterval int) error {
+	if p.DB == nil {
+		return pkg.ErrNoDB
+	}
+
+	var flag mp4.Flag
+	if strings.HasSuffix(streamPath, ".fmp4") {
+		flag = mp4.FLAG_FRAGMENT
+		streamPath = strings.TrimSuffix(streamPath, ".fmp4")
+	} else {
+		streamPath = strings.TrimSuffix(streamPath, ".mp4")
+	}
+
+	// 查询数据库获取符合条件的片段
+	queryRecord := m7s.RecordStream{
+		Type: "mp4",
+	}
+	var streams []m7s.RecordStream
+	p.DB.Where(&queryRecord).Find(&streams, "end_time>? AND start_time<? AND stream_path=?", startTime, endTime, streamPath)
+	if len(streams) == 0 {
+		return fmt.Errorf("no matching MP4 segments found")
+	}
+
+	// 创建输出文件
+	outputFile := writer
+
+	p.Info("extracting compressed video", "streamPath", streamPath, "start", startTime, "end", endTime,
+		"gopSeconds", gopSeconds, "gopInterval", gopInterval)
+
+	muxer := mp4.NewMuxer(flag)
+	ftyp := muxer.CreateFTYPBox()
+	n := ftyp.Size()
+	muxer.CurrentOffset = int64(n)
+	var videoTrack *mp4.Track
+	sampleOffset := muxer.CurrentOffset + mp4.BeforeMdatData
+	mdatOffset := sampleOffset
+
+	//var audioTrack *mp4.Track
+	var extraData []byte
+
+	// 压缩相关变量
+	currentGOPCount := -1
+	inGOP := false
+	targetFrameInterval := 40 // 25fps对应的毫秒间隔 (1000/25=40ms)
+	var filteredSamples []box.Sample
+	//var lastVideoTimestamp uint32
+	var timescale uint32 = 1000 // 默认时间刻度为1000 (毫秒)
+	var currentGopStartTime int64 = -1
+
+	// 仅处理视频轨道
+	for i, stream := range streams {
+		file, err := os.Open(stream.FilePath)
+		if err != nil {
+			return fmt.Errorf("failed to open file %s: %v", stream.FilePath, err)
+		}
+		defer file.Close()
+
+		p.Info("processing segment", "file", file.Name())
+		demuxer := mp4.NewDemuxer(file)
+		err = demuxer.Demux()
+		if err != nil {
+			p.Warn("demux error, skipping segment", "error", err, "file", stream.FilePath)
+			continue
+		}
+
+		// 确保有视频轨道
+		var hasVideo bool
+		for _, track := range demuxer.Tracks {
+			if track.Cid.IsVideo() {
+				hasVideo = true
+				// 只在第一个片段或关键帧变化时更新extraData
+				if extraData == nil || !bytes.Equal(extraData, track.ExtraData) {
+					extraData = track.ExtraData
+					if videoTrack == nil {
+						videoTrack = muxer.AddTrack(track.Cid)
+						videoTrack.ExtraData = extraData
+						videoTrack.Width = track.Width
+						videoTrack.Height = track.Height
+					}
+				}
+				break
+			}
+		}
+
+		if !hasVideo {
+			p.Warn("no video track found in segment", "file", stream.FilePath)
+			continue
+		}
+
+		// 处理起始时间边界
+		var tsOffset int64
+		if i == 0 {
+			startTimestamp := startTime.Sub(stream.StartTime).Milliseconds()
+			if startTimestamp < 0 {
+				startTimestamp = 0
+			}
+			startSample, err := demuxer.SeekTime(uint64(startTimestamp))
+			if err == nil {
+				tsOffset = -int64(startSample.Timestamp)
+			}
+		}
+
+		// 处理样本
+		for track, sample := range demuxer.RangeSample {
+			if !track.Cid.IsVideo() {
+				continue
+			}
+
+			//for _, sample := range samples {
+			adjustedTimestamp := sample.Timestamp + uint32(tsOffset)
+
+			// 处理GOP逻辑
+			if sample.KeyFrame {
+				currentGOPCount++
+				inGOP = false
+				if currentGOPCount%gopInterval == 0 {
+					currentGopStartTime = int64(sample.Timestamp)
+					inGOP = true
+				}
+			}
+
+			// 跳过不在当前GOP的帧
+			if !inGOP {
+				currentGopStartTime = -1
+				continue
+			}
+
+			// 如果不在有效的GOP中，跳过
+			if currentGopStartTime == -1 {
+				continue
+			}
+
+			// 检查是否超过gopSeconds限制
+			currentTime := int64(sample.Timestamp)
+			gopElapsed := float64(currentTime-currentGopStartTime) / float64(timescale)
+			if gopSeconds > 0 && gopElapsed > gopSeconds {
+				continue
+			}
+
+			// 处理结束时间边界
+			if i == len(streams)-1 && int64(adjustedTimestamp) > endTime.Sub(streams[0].StartTime).Milliseconds() {
+				continue
+			}
+
+			// 确保样本数据有效
+			if sample.Size <= 0 || sample.Size > 10*1024*1024 { // 10MB限制
+				p.Warn("invalid sample size", "size", sample.Size, "timestamp", sample.Timestamp)
+				continue
+			}
+
+			// 读取样本数据
+			if _, err := file.Seek(sample.Offset, io.SeekStart); err != nil {
+				p.Warn("seek error", "error", err, "offset", sample.Offset)
+				continue
+			}
+			data := make([]byte, sample.Size)
+			if _, err := io.ReadFull(file, data); err != nil {
+				p.Warn("read sample error", "error", err, "size", sample.Size)
+				continue
+			}
+
+			// 创建新的样本
+			newSample := box.Sample{
+				KeyFrame:  sample.KeyFrame,
+				Data:      data,
+				Timestamp: adjustedTimestamp,
+				Offset:    sampleOffset,
+				Size:      sample.Size,
+				Duration:  sample.Duration,
+			}
+
+			// p.Info("Compressed", "KeyFrame", newSample.KeyFrame,
+			// 	"CTS", newSample.CTS,
+			// 	"Timestamp", newSample.Timestamp,
+			// 	"Offset", newSample.Offset,
+			// 	"Size", newSample.Size,
+			// 	"Duration", newSample.Duration,
+			// 	"Data", Bytes2HexStr(newSample.Data, 16))
+
+			sampleOffset += int64(newSample.Size)
+			filteredSamples = append(filteredSamples, newSample)
+
+		}
+	}
+
+	if len(filteredSamples) == 0 {
+		return fmt.Errorf("no valid video samples found")
+	}
+
+	// 按25fps重新计算时间戳
+	for i := range filteredSamples {
+		filteredSamples[i].Timestamp = uint32(i * targetFrameInterval)
+	}
+
+	// 添加样本到轨道
+	for _, sample := range filteredSamples {
+		videoTrack.AddSampleEntry(sample)
+	}
+
+	// 计算视频时长
+	videoDuration := uint32(len(filteredSamples) * targetFrameInterval)
+
+	// 写入输出文件
+	if flag == 0 {
+		// 非分片MP4处理
+		moovSize := muxer.MakeMoov().Size()
+		dataSize := uint64(sampleOffset - mdatOffset)
+
+		// 调整sample偏移量
+		for _, track := range muxer.Tracks {
+			for i := range track.Samplelist {
+				track.Samplelist[i].Offset += int64(moovSize)
+			}
+		}
+
+		// 创建MDAT盒子 (添加8字节头)
+		mdatHeaderSize := uint64(8)
+		mdatBox := box.CreateBaseBox(box.TypeMDAT, dataSize+mdatHeaderSize)
+
+		var freeBox *box.FreeBox
+		if mdatBox.HeaderSize() == box.BasicBoxLen {
+			freeBox = box.CreateFreeBox(nil)
+		}
+
+		// 写入文件头
+		_, err := box.WriteTo(outputFile, ftyp, muxer.MakeMoov(), freeBox, mdatBox)
+		if err != nil {
+			return fmt.Errorf("failed to write header: %v", err)
+		}
+
+		for _, track := range muxer.Tracks {
+			for i := range track.Samplelist {
+				track.Samplelist[i].Offset += int64(moovSize)
+				if _, err := outputFile.Write(track.Samplelist[i].Data); err != nil {
+					return err
+				}
+			}
+		}
+	} else {
+		// 分片MP4处理
+		var children []box.IBox
+		moov := muxer.MakeMoov()
+		children = append(children, ftyp, moov)
+
+		// 创建分片
+		for _, sample := range filteredSamples {
+			moof, mdat := muxer.CreateFlagment(videoTrack, sample)
+			children = append(children, moof, mdat)
+		}
+
+		_, err := box.WriteTo(outputFile, children...)
+		if err != nil {
+			return fmt.Errorf("failed to write fragmented MP4: %v", err)
+		}
+	}
+
+	p.Info("compressed video saved",
+		"originalDuration", (endTime.Sub(startTime)).Milliseconds(),
+		"compressedDuration", videoDuration,
+		"frameCount", len(filteredSamples),
+		"fps", 25)
+	return nil
+}
+
+/*
+根据时间范围提取视频片段
+njtv/glgc.mp4?
+timest=1748620153000&
+outputPath=/opt/njtv/gop_tmp_1748620153000.mp4
+
+原理：根据时间戳找到最近的mp4文件，再从mp4 文件中找到最近gop 生成mp4 文件
+*/
+func (p *MP4Plugin) extractGopVideo(streamPath string, targetTime time.Time, writer io.Writer) (float64, error) {
+	if p.DB == nil {
+		return 0, pkg.ErrNoDB
+	}
+
+	var flag mp4.Flag
+	if strings.HasSuffix(streamPath, ".fmp4") {
+		flag = mp4.FLAG_FRAGMENT
+		streamPath = strings.TrimSuffix(streamPath, ".fmp4")
+	} else {
+		streamPath = strings.TrimSuffix(streamPath, ".mp4")
+	}
+
+	// 查询数据库获取符合条件的片段
+	queryRecord := m7s.RecordStream{
+		Type: "mp4",
+	}
+	var streams []m7s.RecordStream
+	p.DB.Where(&queryRecord).Find(&streams, "end_time>=? AND start_time<=? AND stream_path=?", targetTime, targetTime, streamPath)
+	if len(streams) == 0 {
+		return 0, fmt.Errorf("no matching MP4 segments found")
+	}
+
+	// 创建输出文件
+	outputFile := writer
+
+	p.Info("extracting compressed video", "streamPath", streamPath, "targetTime", targetTime)
+
+	muxer := mp4.NewMuxer(flag)
+	ftyp := muxer.CreateFTYPBox()
+	n := ftyp.Size()
+	muxer.CurrentOffset = int64(n)
+	var videoTrack *mp4.Track
+	sampleOffset := muxer.CurrentOffset + mp4.BeforeMdatData
+	mdatOffset := sampleOffset
+
+	//var audioTrack *mp4.Track
+	var extraData []byte
+
+	// 压缩相关变量
+	findGOP := false
+	targetFrameInterval := 40 // 25fps对应的毫秒间隔 (1000/25=40ms)
+	var filteredSamples []box.Sample
+	//var lastVideoTimestamp uint32
+	var timescale uint32 = 1000 // 默认时间刻度为1000 (毫秒)
+	var currentGopStartTime int64 = -1
+	var gopElapsed float64 = 0
+	// 仅处理视频轨道
+	for _, stream := range streams {
+		file, err := os.Open(stream.FilePath)
+		if err != nil {
+			return 0, fmt.Errorf("failed to open file %s: %v", stream.FilePath, err)
+		}
+		defer file.Close()
+
+		p.Info("processing segment", "file", file.Name())
+		demuxer := mp4.NewDemuxer(file)
+		err = demuxer.Demux()
+		if err != nil {
+			p.Warn("demux error, skipping segment", "error", err, "file", stream.FilePath)
+			continue
+		}
+
+		// 确保有视频轨道
+		var hasVideo bool
+		for _, track := range demuxer.Tracks {
+			if track.Cid.IsVideo() {
+				hasVideo = true
+				// 只在第一个片段或关键帧变化时更新extraData
+				if extraData == nil || !bytes.Equal(extraData, track.ExtraData) {
+					extraData = track.ExtraData
+					if videoTrack == nil {
+						videoTrack = muxer.AddTrack(track.Cid)
+						videoTrack.ExtraData = extraData
+						videoTrack.Width = track.Width
+						videoTrack.Height = track.Height
+					}
+				}
+				break
+			}
+		}
+
+		if !hasVideo {
+			p.Warn("no video track found in segment", "file", stream.FilePath)
+			continue
+		}
+
+		// 处理起始时间边界
+		var tsOffset int64
+
+		startTimestamp := targetTime.Sub(stream.StartTime).Milliseconds()
+
+		// p.Info("extractGop", "targetTime", targetTime,
+		// 	"stream.StartTime", stream.StartTime,
+		// 	"startTimestamp", startTimestamp)
+
+		if startTimestamp < 0 {
+			startTimestamp = 0
+		}
+		//通过时间戳定位到最近的‌关键帧‌（如视频IDR帧），返回的startSample是该关键帧对应的样本
+		startSample, err := demuxer.SeekTime(uint64(startTimestamp))
+		if err == nil {
+			tsOffset = -int64(startSample.Timestamp)
+		}
+
+		//p.Info("extractGop", "startSample", startSample)
+
+		// 处理样本
+		//RangeSample迭代的是‌当前时间范围内的所有样本‌（可能包含非关键帧），顺序取决于MP4文件中样本的物理存储顺序
+		for track, sample := range demuxer.RangeSample {
+			if !track.Cid.IsVideo() {
+				continue
+			}
+
+			if sample.Timestamp < startSample.Timestamp {
+				continue
+			}
+
+			//for _, sample := range samples {
+			adjustedTimestamp := sample.Timestamp + uint32(tsOffset)
+
+			// 处理GOP逻辑,已经处理完上一个gop
+			if sample.KeyFrame && findGOP {
+				break
+			}
+
+			// 处理GOP逻辑
+			if sample.KeyFrame && !findGOP {
+				findGOP = true
+				currentGopStartTime = int64(sample.Timestamp)
+			}
+
+			// 跳过不在当前GOP的帧
+			if !findGOP {
+				currentGopStartTime = -1
+				continue
+			}
+			// 检查是否超过gopSeconds限制
+			currentTime := int64(sample.Timestamp)
+			gopElapsed = float64(currentTime-currentGopStartTime) / float64(timescale)
+
+			// 确保样本数据有效
+			if sample.Size <= 0 || sample.Size > 10*1024*1024 { // 10MB限制
+				p.Warn("invalid sample size", "size", sample.Size, "timestamp", sample.Timestamp)
+				continue
+			}
+
+			// 读取样本数据
+			if _, err := file.Seek(sample.Offset, io.SeekStart); err != nil {
+				p.Warn("seek error", "error", err, "offset", sample.Offset)
+				continue
+			}
+			data := make([]byte, sample.Size)
+			if _, err := io.ReadFull(file, data); err != nil {
+				p.Warn("read sample error", "error", err, "size", sample.Size)
+				continue
+			}
+
+			// 创建新的样本
+			newSample := box.Sample{
+				KeyFrame:  sample.KeyFrame,
+				Data:      data,
+				Timestamp: adjustedTimestamp,
+				Offset:    sampleOffset,
+				Size:      sample.Size,
+				Duration:  sample.Duration,
+			}
+
+			// p.Info("extractGop", "KeyFrame", newSample.KeyFrame,
+			// 	"CTS", newSample.CTS,
+			// 	"Timestamp", newSample.Timestamp,
+			// 	"Offset", newSample.Offset,
+			// 	"Size", newSample.Size,
+			// 	"Duration", newSample.Duration,
+			// 	"Data", Bytes2HexStr(newSample.Data, 16))
+
+			sampleOffset += int64(newSample.Size)
+			filteredSamples = append(filteredSamples, newSample)
+
+		}
+	}
+
+	if len(filteredSamples) == 0 {
+		return 0, fmt.Errorf("no valid video samples found")
+	}
+
+	// 按25fps重新计算时间戳
+	for i := range filteredSamples {
+		filteredSamples[i].Timestamp = uint32(i * targetFrameInterval)
+	}
+
+	// 添加样本到轨道
+	for _, sample := range filteredSamples {
+		videoTrack.AddSampleEntry(sample)
+	}
+
+	// 计算视频时长
+	videoDuration := uint32(len(filteredSamples) * targetFrameInterval)
+
+	// 写入输出文件
+	if flag == 0 {
+		// 非分片MP4处理
+		moovSize := muxer.MakeMoov().Size()
+		dataSize := uint64(sampleOffset - mdatOffset)
+
+		// 调整sample偏移量
+		for _, track := range muxer.Tracks {
+			for i := range track.Samplelist {
+				track.Samplelist[i].Offset += int64(moovSize)
+			}
+		}
+
+		// 创建MDAT盒子 (添加8字节头)
+		mdatHeaderSize := uint64(8)
+		mdatBox := box.CreateBaseBox(box.TypeMDAT, dataSize+mdatHeaderSize)
+
+		var freeBox *box.FreeBox
+		if mdatBox.HeaderSize() == box.BasicBoxLen {
+			freeBox = box.CreateFreeBox(nil)
+		}
+
+		// 写入文件头
+		_, err := box.WriteTo(outputFile, ftyp, muxer.MakeMoov(), freeBox, mdatBox)
+		if err != nil {
+			return 0, fmt.Errorf("failed to write header: %v", err)
+		}
+
+		for _, track := range muxer.Tracks {
+			for i := range track.Samplelist {
+				track.Samplelist[i].Offset += int64(moovSize)
+				if _, err := outputFile.Write(track.Samplelist[i].Data); err != nil {
+					return 0, err
+				}
+			}
+		}
+	} else {
+		// 分片MP4处理
+		var children []box.IBox
+		moov := muxer.MakeMoov()
+		children = append(children, ftyp, moov)
+
+		// 创建分片
+		for _, sample := range filteredSamples {
+			moof, mdat := muxer.CreateFlagment(videoTrack, sample)
+			children = append(children, moof, mdat)
+		}
+
+		_, err := box.WriteTo(outputFile, children...)
+		if err != nil {
+			return 0, fmt.Errorf("failed to write fragmented MP4: %v", err)
+		}
+	}
+	p.Info("extract gop video saved",
+		"targetTime", targetTime,
+		"compressedDuration", videoDuration,
+		"gopElapsed", gopElapsed,
+		"frameCount", len(filteredSamples),
+		"fps", 25)
+	return gopElapsed, nil
+}
+
+/*
+提取压缩视频
+
+GET http://192.168.0.238:8080/mp4/extract/compressed/
+njtv/glgc.mp4?
+start=1748620153000&
+end=1748620453000&
+outputPath=/opt/njtv/1748620153000.mp4
+gopSeconds=1&
+gopInterval=1&
+*/
+func (p *MP4Plugin) extractCompressedVideoHandel(w http.ResponseWriter, r *http.Request) {
+	streamPath := r.PathValue("streamPath")
+	query := r.URL.Query()
+	// 合并多个 mp4
+	startTime, endTime, err := util.TimeRangeQueryParse(query)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	p.Info("extractCompressedVideoHandel", "streamPath", streamPath, "start", startTime, "end", endTime)
+
+	gopSeconds, _ := strconv.ParseFloat(query.Get("gopSeconds"), 64)
+	gopInterval, _ := strconv.Atoi(query.Get("gopInterval"))
+
+	if gopSeconds == 0 {
+		gopSeconds = 1
+	}
+	if gopInterval == 0 {
+		gopInterval = 1
+	}
+
+	// 设置响应头
+	w.Header().Set("Content-Type", "video/mp4")
+	w.Header().Set("Content-Disposition", "attachment; filename=\"compressed_video.mp4\"")
+
+	err = p.extractCompressedVideo(streamPath, startTime, endTime, w, gopSeconds, gopInterval)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+func (p *MP4Plugin) extractGopVideoHandel(w http.ResponseWriter, r *http.Request) {
+	streamPath := r.PathValue("streamPath")
+	query := r.URL.Query()
+
+	targetTimeString := query.Get("targetTime")
+	// 合并多个 mp4
+	targetTime, err := util.UnixTimeQueryParse(targetTimeString)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	p.Info("extractGopVideoHandel", "streamPath", streamPath, "targetTime", targetTime)
+
+	// 设置响应头
+	w.Header().Set("Content-Type", "video/mp4")
+	w.Header().Set("Content-Disposition", "attachment; filename=\"gop_video.mp4\"")
+
+	_, err = p.extractGopVideo(streamPath, targetTime, w)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+func (p *MP4Plugin) snapHandel(w http.ResponseWriter, r *http.Request) {
+	streamPath := r.PathValue("streamPath")
+	query := r.URL.Query()
+
+	targetTimeString := query.Get("targetTime")
+	// 合并多个 mp4
+	targetTime, err := util.UnixTimeQueryParse(targetTimeString)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	p.Info("snapHandel", "streamPath", streamPath, "targetTime", targetTime)
+
+	// 设置响应头
+	w.Header().Set("Content-Type", "image/jpeg")
+	w.Header().Set("Content-Disposition", "attachment; filename=\"snapshot.jpg\"")
+
+	err = p.snapToWriter(streamPath, targetTime, w)
+	if err != nil {
+		p.Info("snapHandel", "err", err)
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+}
+
+func (p *MP4Plugin) snapToWriter(streamPath string, targetTime time.Time, writer io.Writer) error {
+	if p.DB == nil {
+		return pkg.ErrNoDB
+	}
+
+	var flag mp4.Flag
+	if strings.HasSuffix(streamPath, ".fmp4") {
+		flag = mp4.FLAG_FRAGMENT
+		streamPath = strings.TrimSuffix(streamPath, ".fmp4")
+	} else {
+		streamPath = strings.TrimSuffix(streamPath, ".mp4")
+	}
+
+	// 查询数据库获取符合条件的片段
+	queryRecord := m7s.RecordStream{
+		Type: "mp4",
+	}
+	var streams []m7s.RecordStream
+	p.DB.Where(&queryRecord).Find(&streams, "end_time>=? AND start_time<=? AND stream_path=?", targetTime, targetTime, streamPath)
+	if len(streams) == 0 {
+		return fmt.Errorf("no matching MP4 segments found")
+	}
+
+	muxer := mp4.NewMuxer(flag)
+	ftyp := muxer.CreateFTYPBox()
+	n := ftyp.Size()
+	muxer.CurrentOffset = int64(n)
+	var videoTrack *mp4.Track
+	sampleOffset := muxer.CurrentOffset + mp4.BeforeMdatData
+
+	//var audioTrack *mp4.Track
+	var extraData []byte
+
+	// 压缩相关变量
+	findGOP := false
+	var filteredSamples []box.Sample
+	var sampleIdx = 0
+	// 仅处理视频轨道
+	for _, stream := range streams {
+		file, err := os.Open(stream.FilePath)
+		if err != nil {
+			return fmt.Errorf("failed to open file %s: %v", stream.FilePath, err)
+		}
+		defer file.Close()
+
+		p.Info("processing segment", "file", file.Name())
+		demuxer := mp4.NewDemuxer(file)
+		err = demuxer.Demux()
+		if err != nil {
+			p.Warn("demux error, skipping segment", "error", err, "file", stream.FilePath)
+			continue
+		}
+
+		// 确保有视频轨道
+		var hasVideo bool
+		for _, track := range demuxer.Tracks {
+			if track.Cid.IsVideo() {
+				hasVideo = true
+				// 只在第一个片段或关键帧变化时更新extraData
+				if extraData == nil || !bytes.Equal(extraData, track.ExtraData) {
+					extraData = track.ExtraData
+					if videoTrack == nil {
+						videoTrack = muxer.AddTrack(track.Cid)
+						videoTrack.ExtraData = extraData
+						videoTrack.Width = track.Width
+						videoTrack.Height = track.Height
+					}
+				}
+				break
+			}
+		}
+
+		if !hasVideo {
+			p.Warn("no video track found in segment", "file", stream.FilePath)
+			continue
+		}
+
+		// 处理起始时间边界
+		var tsOffset int64
+
+		startTimestamp := targetTime.Sub(stream.StartTime).Milliseconds()
+
+		if startTimestamp < 0 {
+			startTimestamp = 0
+		}
+		//通过时间戳定位到最近的‌关键帧‌（如视频IDR帧），返回的startSample是该关键帧对应的样本
+		startSample, err := demuxer.SeekTime(uint64(startTimestamp))
+		if err == nil {
+			tsOffset = -int64(startSample.Timestamp)
+		}
+
+		// 处理样本
+		//RangeSample迭代的是‌当前时间范围内的所有样本‌（可能包含非关键帧），顺序取决于MP4文件中样本的物理存储顺序
+		for track, sample := range demuxer.RangeSample {
+			if !track.Cid.IsVideo() {
+				continue
+			}
+
+			if sample.Timestamp < startSample.Timestamp {
+				continue
+			}
+			//记录GOP内帧的序号，没有考虑B帧的情况
+			if sample.Timestamp < uint32(startTimestamp) {
+				sampleIdx++
+			}
+
+			adjustedTimestamp := sample.Timestamp + uint32(tsOffset)
+
+			// 处理GOP逻辑,已经处理完上一个gop
+			if sample.KeyFrame && findGOP {
+				break
+			}
+
+			// 处理GOP逻辑
+			if sample.KeyFrame && !findGOP {
+				findGOP = true
+			}
+
+			// 跳过不在当前GOP的帧
+			if !findGOP {
+				continue
+			}
+
+			// 确保样本数据有效
+			if sample.Size <= 0 || sample.Size > 10*1024*1024 { // 10MB限制
+				p.Warn("invalid sample size", "size", sample.Size, "timestamp", sample.Timestamp)
+				continue
+			}
+
+			// 读取样本数据
+			if _, err := file.Seek(sample.Offset, io.SeekStart); err != nil {
+				p.Warn("seek error", "error", err, "offset", sample.Offset)
+				continue
+			}
+			data := make([]byte, sample.Size)
+			if _, err := io.ReadFull(file, data); err != nil {
+				p.Warn("read sample error", "error", err, "size", sample.Size)
+				continue
+			}
+
+			// 创建新的样本
+			newSample := box.Sample{
+				KeyFrame:  sample.KeyFrame,
+				Data:      data,
+				Timestamp: adjustedTimestamp,
+				Offset:    sampleOffset,
+				Size:      sample.Size,
+				Duration:  sample.Duration,
+			}
+
+			sampleOffset += int64(newSample.Size)
+			filteredSamples = append(filteredSamples, newSample)
+		}
+	}
+
+	if len(filteredSamples) == 0 {
+		return fmt.Errorf("no valid video samples found")
+	}
+
+	// 按25fps重新计算时间戳
+	targetFrameInterval := 40 // 25fps对应的毫秒间隔 (1000/25=40ms)
+	for i := range filteredSamples {
+		filteredSamples[i].Timestamp = uint32(i * targetFrameInterval)
+	}
+
+	p.Info("extract gop and snap",
+		"targetTime", targetTime,
+		"frist", filteredSamples[0].Timestamp,
+		"sampleIdx", sampleIdx,
+		"frameCount", len(filteredSamples))
+
+	err := ProcessWithFFmpeg(filteredSamples, sampleIdx, videoTrack, writer)
+	if err != nil {
+		return err
+	}
+
+	p.Info("extract gop and snap saved",
+		"targetTime", targetTime,
+		"frameCount", len(filteredSamples))
+
+	return nil
+}

plugin/mp4/box_structure.md

@@ -37,9 +37,27 @@
 | | | | | | sbgp | | sample-to-group |
 | | | | | | sgpd | | sample group description |
 | | | | | | subs | | sub-sample information |
+| | | udta | | | | | user-data (track level)<br>轨道级别的用户数据容器 |
+| | | | cprt | | | | copyright etc.<br>版权信息 |
+| | | | titl | | | | title<br>标题 |
+| | | | auth | | | | author<br>作者 |
 | | mvex | | | | | | movie extends box |
 | | | mehd | | | | | movie extends header box |
 | | | trex | | | | ✓ | track extends defaults |
+| | udta | | | | | | user-data (movie level)<br>电影级别的用户数据容器 |
+| | | cprt | | | | | copyright etc.<br>版权信息 |
+| | | titl | | | | | title<br>标题 |
+| | | auth | | | | | author<br>作者 |
+| | | albm | | | | | album<br>专辑 |
+| | | yrrc | | | | | year<br>年份 |
+| | | rtng | | | | | rating<br>评级 |
+| | | clsf | | | | | classification<br>分类 |
+| | | kywd | | | | | keywords<br>关键词 |
+| | | loci | | | | | location information<br>位置信息 |
+| | | dscp | | | | | description<br>描述 |
+| | | perf | | | | | performer<br>表演者 |
+| | | gnre | | | | | genre<br>类型 |
+| | | meta | | | | | metadata atom<br>元数据原子 |
 | | ipmc | | | | | | IPMP Control Box |
 | moof | | | | | | | movie fragment |
 | | mfhd | | | | | ✓ | movie fragment header |
@@ -54,8 +72,10 @@
 | mdat | | | | | | | media data container |
 | free | | | | | | | free space |
 | skip | | | | | | | free space |
-| | udta | | | | | | user-data |
-| | | cprt | | | | | copyright etc. |
+| udta | | | | | | | user-data (file level)<br>文件级别的用户数据容器 |
+| | cprt | | | | | | copyright etc.<br>版权信息 |
+| | titl | | | | | | title<br>标题 |
+| | auth | | | | | | author<br>作者 |
 | meta | | | | | | | metadata |
 | | hdlr | | | | | ✓ | handler, declares the metadata (handler) type |
 | | dinf | | | | | | data information box, container |

plugin/mp4/exception.go

@@ -91,10 +91,7 @@ func (p *DeleteRecordTask) deleteOldestFile() {
 	}
 	for _, filePath := range filePaths {
 		for p.getDiskOutOfSpace(filePath) {
-			queryRecord := m7s.RecordStream{
-				EventLevel: m7s.EventLevelLow, // 查询条件：event_level = 1,非重要事件
-			}
-			var eventRecords []m7s.RecordStream
+			var eventRecords []m7s.EventRecordStream
 			// 使用不同的方法进行路径匹配，避免ESCAPE语法问题
 			// 解决方案：用MySQL能理解的简单方式匹配路径前缀
 			basePath := filePath
@@ -103,7 +100,7 @@ func (p *DeleteRecordTask) deleteOldestFile() {
 			searchPattern := basePath + "%"
 			p.Info("deleteOldestFile", "searching with path pattern", searchPattern)
 
-			err := p.DB.Where(&queryRecord).Where("end_time IS NOT NULL").
+			err := p.DB.Where("event_id=0 AND end_time IS NOT NULL").
 				Where("file_path LIKE ?", searchPattern).
 				Order("end_time ASC").Find(&eventRecords).Error
 			if err == nil {
@@ -149,16 +146,13 @@ func (t *DeleteRecordTask) Tick(any) {
 	if t.RecordFileExpireDays <= 0 {
 		return
 	}
-	//搜索event_records表中event_level值为1的（非重要）数据，并将其create_time与当前时间比对，大于RecordFileExpireDays则进行删除，数据库标记is_delete为1，磁盘上删除录像文件
-	var eventRecords []m7s.RecordStream
+	//搜索event_records表中event_id值为0的（非事件）录像，并将其create_time与当前时间比对，大于RecordFileExpireDays则进行删除，数据库标记is_delete为1，磁盘上删除录像文件
+	var records []m7s.RecordStream
 	expireTime := time.Now().AddDate(0, 0, -t.RecordFileExpireDays)
 	t.Debug("RecordFileExpireDays is set to auto delete oldestfile", "expireTime", expireTime.Format("2006-01-02 15:04:05"))
-	queryRecord := m7s.RecordStream{
-		EventLevel: m7s.EventLevelLow, // 查询条件：event_level = low,非重要事件
-	}
-	err := t.DB.Where(&queryRecord).Find(&eventRecords, "end_time < ? AND end_time IS NOT NULL", expireTime).Error
+	err := t.DB.Find(&records, "end_time < ? AND end_time IS NOT NULL", expireTime).Error
 	if err == nil {
-		for _, record := range eventRecords {
+		for _, record := range records {
 			t.Info("RecordFileExpireDays is set to auto delete oldestfile", "ID", record.ID, "create time", record.EndTime, "filepath", record.FilePath)
 			err = os.Remove(record.FilePath)
 			if err != nil {

plugin/mp4/index.go

@@ -76,7 +76,10 @@ var _ = m7s.InstallPlugin[MP4Plugin](m7s.PluginMeta{
 
 func (p *MP4Plugin) RegisterHandler() map[string]http.HandlerFunc {
 	return map[string]http.HandlerFunc{
-		"/download/{streamPath...}": p.download,
+		"/download/{streamPath...}":           p.download,
+		"/extract/compressed/{streamPath...}": p.extractCompressedVideoHandel,
+		"/extract/gop/{streamPath...}":        p.extractGopVideoHandel,
+		"/snap/{streamPath...}":               p.snapHandel,
 	}
 }
 

plugin/mp4/pb/mp4.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.36.5
-// 	protoc        v5.28.3
+// 	protoc-gen-go v1.36.6
+// 	protoc        v5.29.3
 // source: mp4.proto
 
 package pb
@@ -587,123 +587,74 @@ func (x *ResponseStopRecord) GetData() uint64 {
 
 var File_mp4_proto protoreflect.FileDescriptor
 
-var file_mp4_proto_rawDesc = string([]byte{
-	0x0a, 0x09, 0x6d, 0x70, 0x34, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x6d, 0x70, 0x34,
-	0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e,
-	0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b,
-	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f,
-	0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f,
-	0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x0c, 0x67, 0x6c, 0x6f,
-	0x62, 0x61, 0x6c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xd7, 0x01, 0x0a, 0x0d, 0x52, 0x65,
-	0x71, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x1e, 0x0a, 0x0a, 0x73,
-	0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x0a, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x74, 0x68, 0x12, 0x14, 0x0a, 0x05, 0x72,
-	0x61, 0x6e, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x72, 0x61, 0x6e, 0x67,
-	0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x04,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x67,
-	0x65, 0x4e, 0x75, 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x70, 0x61, 0x67, 0x65,
-	0x4e, 0x75, 0x6d, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x61, 0x67, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x18,
-	0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x70, 0x61, 0x67, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x12,
-	0x12, 0x0a, 0x04, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6d,
-	0x6f, 0x64, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x4c, 0x65, 0x76, 0x65,
-	0x6c, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x4c, 0x65,
-	0x76, 0x65, 0x6c, 0x22, 0x91, 0x01, 0x0a, 0x0f, 0x52, 0x65, 0x71, 0x52, 0x65, 0x63, 0x6f, 0x72,
-	0x64, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x74, 0x72, 0x65, 0x61,
-	0x6d, 0x50, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x74, 0x72,
-	0x65, 0x61, 0x6d, 0x50, 0x61, 0x74, 0x68, 0x12, 0x10, 0x0a, 0x03, 0x69, 0x64, 0x73, 0x18, 0x02,
-	0x20, 0x03, 0x28, 0x0d, 0x52, 0x03, 0x69, 0x64, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x74, 0x61,
-	0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74,
-	0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69,
-	0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d,
-	0x65, 0x12, 0x14, 0x0a, 0x05, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x05, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x22, 0x90, 0x02, 0x0a, 0x0e, 0x52, 0x65, 0x71, 0x45,
-	0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x74,
-	0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
-	0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x74, 0x68, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x76,
-	0x65, 0x6e, 0x74, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x76, 0x65,
-	0x6e, 0x74, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x4e, 0x61, 0x6d,
-	0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x4e, 0x61,
-	0x6d, 0x65, 0x12, 0x26, 0x0a, 0x0e, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x44, 0x75, 0x72, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x62, 0x65, 0x66, 0x6f,
-	0x72, 0x65, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x24, 0x0a, 0x0d, 0x61, 0x66,
-	0x74, 0x65, 0x72, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x0d, 0x61, 0x66, 0x74, 0x65, 0x72, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x12, 0x1c, 0x0a, 0x09, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x44, 0x65, 0x73, 0x63, 0x18, 0x06, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x09, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x44, 0x65, 0x73, 0x63, 0x12, 0x1e,
-	0x0a, 0x0a, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x07, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x0a, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x1a,
-	0x0a, 0x08, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x08, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x22, 0x57, 0x0a, 0x13, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x72,
-	0x64, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52,
-	0x04, 0x63, 0x6f, 0x64, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12,
-	0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x64,
-	0x61, 0x74, 0x61, 0x22, 0x83, 0x01, 0x0a, 0x0e, 0x52, 0x65, 0x71, 0x53, 0x74, 0x61, 0x72, 0x74,
-	0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d,
-	0x50, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x74, 0x72, 0x65,
-	0x61, 0x6d, 0x50, 0x61, 0x74, 0x68, 0x12, 0x35, 0x0a, 0x08, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65,
-	0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
-	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x52, 0x08, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x1a, 0x0a,
-	0x08, 0x66, 0x69, 0x6c, 0x65, 0x50, 0x61, 0x74, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x08, 0x66, 0x69, 0x6c, 0x65, 0x50, 0x61, 0x74, 0x68, 0x22, 0x57, 0x0a, 0x13, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64,
-	0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04,
-	0x63, 0x6f, 0x64, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x12,
-	0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x64, 0x61,
-	0x74, 0x61, 0x22, 0x2f, 0x0a, 0x0d, 0x52, 0x65, 0x71, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x63,
-	0x6f, 0x72, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x74,
-	0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50,
-	0x61, 0x74, 0x68, 0x22, 0x56, 0x0a, 0x12, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x53,
-	0x74, 0x6f, 0x70, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x64,
-	0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x12, 0x18, 0x0a,
-	0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
-	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18,
-	0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x32, 0xc4, 0x04, 0x0a, 0x03,
-	0x61, 0x70, 0x69, 0x12, 0x57, 0x0a, 0x04, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x12, 0x2e, 0x6d, 0x70,
-	0x34, 0x2e, 0x52, 0x65, 0x71, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x4c, 0x69, 0x73, 0x74, 0x1a,
-	0x14, 0x2e, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x25, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x12, 0x1d, 0x2f,
-	0x6d, 0x70, 0x34, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x6c, 0x69, 0x73, 0x74, 0x2f, 0x7b, 0x73, 0x74,
-	0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x74, 0x68, 0x3d, 0x2a, 0x2a, 0x7d, 0x12, 0x54, 0x0a, 0x07,
-	0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a,
-	0x17, 0x2e, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x22, 0x18, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12,
-	0x12, 0x10, 0x2f, 0x6d, 0x70, 0x34, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x63, 0x61, 0x74, 0x61, 0x6c,
-	0x6f, 0x67, 0x12, 0x62, 0x0a, 0x06, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x14, 0x2e, 0x6d,
-	0x70, 0x34, 0x2e, 0x52, 0x65, 0x71, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x44, 0x65, 0x6c, 0x65,
-	0x74, 0x65, 0x1a, 0x16, 0x2e, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x2e, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x22, 0x2a, 0x82, 0xd3, 0xe4, 0x93,
-	0x02, 0x24, 0x3a, 0x01, 0x2a, 0x22, 0x1f, 0x2f, 0x6d, 0x70, 0x34, 0x2f, 0x61, 0x70, 0x69, 0x2f,
-	0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x2f, 0x7b, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61,
-	0x74, 0x68, 0x3d, 0x2a, 0x2a, 0x7d, 0x12, 0x5c, 0x0a, 0x0a, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x53,
-	0x74, 0x61, 0x72, 0x74, 0x12, 0x13, 0x2e, 0x6d, 0x70, 0x34, 0x2e, 0x52, 0x65, 0x71, 0x45, 0x76,
-	0x65, 0x6e, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x1a, 0x18, 0x2e, 0x6d, 0x70, 0x34, 0x2e,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x63,
-	0x6f, 0x72, 0x64, 0x22, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x3a, 0x01, 0x2a, 0x22, 0x14,
-	0x2f, 0x6d, 0x70, 0x34, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2f, 0x73,
-	0x74, 0x61, 0x72, 0x74, 0x12, 0x67, 0x0a, 0x0b, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x63,
-	0x6f, 0x72, 0x64, 0x12, 0x13, 0x2e, 0x6d, 0x70, 0x34, 0x2e, 0x52, 0x65, 0x71, 0x53, 0x74, 0x61,
-	0x72, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x1a, 0x18, 0x2e, 0x6d, 0x70, 0x34, 0x2e, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x63, 0x6f,
-	0x72, 0x64, 0x22, 0x29, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x23, 0x3a, 0x01, 0x2a, 0x22, 0x1e, 0x2f,
-	0x6d, 0x70, 0x34, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2f, 0x7b, 0x73,
-	0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x74, 0x68, 0x3d, 0x2a, 0x2a, 0x7d, 0x12, 0x63, 0x0a,
-	0x0a, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x12, 0x12, 0x2e, 0x6d, 0x70,
-	0x34, 0x2e, 0x52, 0x65, 0x71, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x1a,
-	0x17, 0x2e, 0x6d, 0x70, 0x34, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x53, 0x74,
-	0x6f, 0x70, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x22, 0x28, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x22,
-	0x3a, 0x01, 0x2a, 0x22, 0x1d, 0x2f, 0x6d, 0x70, 0x34, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x73, 0x74,
-	0x6f, 0x70, 0x2f, 0x7b, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x74, 0x68, 0x3d, 0x2a,
-	0x2a, 0x7d, 0x42, 0x1b, 0x5a, 0x19, 0x6d, 0x37, 0x73, 0x2e, 0x6c, 0x69, 0x76, 0x65, 0x2f, 0x76,
-	0x35, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x2f, 0x6d, 0x70, 0x34, 0x2f, 0x70, 0x62, 0x62,
-	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-})
+const file_mp4_proto_rawDesc = "" +
+	"\n" +
+	"\tmp4.proto\x12\x03mp4\x1a\x1cgoogle/api/annotations.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\fglobal.proto\"\xd7\x01\n" +
+	"\rReqRecordList\x12\x1e\n" +
+	"\n" +
+	"streamPath\x18\x01 \x01(\tR\n" +
+	"streamPath\x12\x14\n" +
+	"\x05range\x18\x02 \x01(\tR\x05range\x12\x14\n" +
+	"\x05start\x18\x03 \x01(\tR\x05start\x12\x10\n" +
+	"\x03end\x18\x04 \x01(\tR\x03end\x12\x18\n" +
+	"\apageNum\x18\x05 \x01(\rR\apageNum\x12\x1a\n" +
+	"\bpageSize\x18\x06 \x01(\rR\bpageSize\x12\x12\n" +
+	"\x04mode\x18\a \x01(\tR\x04mode\x12\x1e\n" +
+	"\n" +
+	"eventLevel\x18\b \x01(\tR\n" +
+	"eventLevel\"\x91\x01\n" +
+	"\x0fReqRecordDelete\x12\x1e\n" +
+	"\n" +
+	"streamPath\x18\x01 \x01(\tR\n" +
+	"streamPath\x12\x10\n" +
+	"\x03ids\x18\x02 \x03(\rR\x03ids\x12\x1c\n" +
+	"\tstartTime\x18\x03 \x01(\tR\tstartTime\x12\x18\n" +
+	"\aendTime\x18\x04 \x01(\tR\aendTime\x12\x14\n" +
+	"\x05range\x18\x05 \x01(\tR\x05range\"\x90\x02\n" +
+	"\x0eReqEventRecord\x12\x1e\n" +
+	"\n" +
+	"streamPath\x18\x01 \x01(\tR\n" +
+	"streamPath\x12\x18\n" +
+	"\aeventId\x18\x02 \x01(\tR\aeventId\x12\x1c\n" +
+	"\teventName\x18\x03 \x01(\tR\teventName\x12&\n" +
+	"\x0ebeforeDuration\x18\x04 \x01(\tR\x0ebeforeDuration\x12$\n" +
+	"\rafterDuration\x18\x05 \x01(\tR\rafterDuration\x12\x1c\n" +
+	"\teventDesc\x18\x06 \x01(\tR\teventDesc\x12\x1e\n" +
+	"\n" +
+	"eventLevel\x18\a \x01(\tR\n" +
+	"eventLevel\x12\x1a\n" +
+	"\bfragment\x18\b \x01(\tR\bfragment\"W\n" +
+	"\x13ResponseEventRecord\x12\x12\n" +
+	"\x04code\x18\x01 \x01(\x05R\x04code\x12\x18\n" +
+	"\amessage\x18\x02 \x01(\tR\amessage\x12\x12\n" +
+	"\x04data\x18\x03 \x01(\rR\x04data\"\x83\x01\n" +
+	"\x0eReqStartRecord\x12\x1e\n" +
+	"\n" +
+	"streamPath\x18\x01 \x01(\tR\n" +
+	"streamPath\x125\n" +
+	"\bfragment\x18\x02 \x01(\v2\x19.google.protobuf.DurationR\bfragment\x12\x1a\n" +
+	"\bfilePath\x18\x03 \x01(\tR\bfilePath\"W\n" +
+	"\x13ResponseStartRecord\x12\x12\n" +
+	"\x04code\x18\x01 \x01(\x05R\x04code\x12\x18\n" +
+	"\amessage\x18\x02 \x01(\tR\amessage\x12\x12\n" +
+	"\x04data\x18\x03 \x01(\x04R\x04data\"/\n" +
+	"\rReqStopRecord\x12\x1e\n" +
+	"\n" +
+	"streamPath\x18\x01 \x01(\tR\n" +
+	"streamPath\"V\n" +
+	"\x12ResponseStopRecord\x12\x12\n" +
+	"\x04code\x18\x01 \x01(\x05R\x04code\x12\x18\n" +
+	"\amessage\x18\x02 \x01(\tR\amessage\x12\x12\n" +
+	"\x04data\x18\x03 \x01(\x04R\x04data2\xca\x04\n" +
+	"\x03api\x12]\n" +
+	"\x04List\x12\x12.mp4.ReqRecordList\x1a\x1a.global.RecordResponseList\"%\x82\xd3\xe4\x93\x02\x1f\x12\x1d/mp4/api/list/{streamPath=**}\x12T\n" +
+	"\aCatalog\x12\x16.google.protobuf.Empty\x1a\x17.global.ResponseCatalog\"\x18\x82\xd3\xe4\x93\x02\x12\x12\x10/mp4/api/catalog\x12b\n" +
+	"\x06Delete\x12\x14.mp4.ReqRecordDelete\x1a\x16.global.ResponseDelete\"*\x82\xd3\xe4\x93\x02$:\x01*\"\x1f/mp4/api/delete/{streamPath=**}\x12\\\n" +
+	"\n" +
+	"EventStart\x12\x13.mp4.ReqEventRecord\x1a\x18.mp4.ResponseEventRecord\"\x1f\x82\xd3\xe4\x93\x02\x19:\x01*\"\x14/mp4/api/event/start\x12g\n" +
+	"\vStartRecord\x12\x13.mp4.ReqStartRecord\x1a\x18.mp4.ResponseStartRecord\")\x82\xd3\xe4\x93\x02#:\x01*\"\x1e/mp4/api/start/{streamPath=**}\x12c\n" +
+	"\n" +
+	"StopRecord\x12\x12.mp4.ReqStopRecord\x1a\x17.mp4.ResponseStopRecord\"(\x82\xd3\xe4\x93\x02\":\x01*\"\x1d/mp4/api/stop/{streamPath=**}B\x1bZ\x19m7s.live/v5/plugin/mp4/pbb\x06proto3"
 
 var (
 	file_mp4_proto_rawDescOnce sync.Once
@@ -719,19 +670,19 @@ func file_mp4_proto_rawDescGZIP() []byte {
 
 var file_mp4_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
 var file_mp4_proto_goTypes = []any{
-	(*ReqRecordList)(nil),       // 0: mp4.ReqRecordList
-	(*ReqRecordDelete)(nil),     // 1: mp4.ReqRecordDelete
-	(*ReqEventRecord)(nil),      // 2: mp4.ReqEventRecord
-	(*ResponseEventRecord)(nil), // 3: mp4.ResponseEventRecord
-	(*ReqStartRecord)(nil),      // 4: mp4.ReqStartRecord
-	(*ResponseStartRecord)(nil), // 5: mp4.ResponseStartRecord
-	(*ReqStopRecord)(nil),       // 6: mp4.ReqStopRecord
-	(*ResponseStopRecord)(nil),  // 7: mp4.ResponseStopRecord
-	(*durationpb.Duration)(nil), // 8: google.protobuf.Duration
-	(*emptypb.Empty)(nil),       // 9: google.protobuf.Empty
-	(*pb.ResponseList)(nil),     // 10: global.ResponseList
-	(*pb.ResponseCatalog)(nil),  // 11: global.ResponseCatalog
-	(*pb.ResponseDelete)(nil),   // 12: global.ResponseDelete
+	(*ReqRecordList)(nil),         // 0: mp4.ReqRecordList
+	(*ReqRecordDelete)(nil),       // 1: mp4.ReqRecordDelete
+	(*ReqEventRecord)(nil),        // 2: mp4.ReqEventRecord
+	(*ResponseEventRecord)(nil),   // 3: mp4.ResponseEventRecord
+	(*ReqStartRecord)(nil),        // 4: mp4.ReqStartRecord
+	(*ResponseStartRecord)(nil),   // 5: mp4.ResponseStartRecord
+	(*ReqStopRecord)(nil),         // 6: mp4.ReqStopRecord
+	(*ResponseStopRecord)(nil),    // 7: mp4.ResponseStopRecord
+	(*durationpb.Duration)(nil),   // 8: google.protobuf.Duration
+	(*emptypb.Empty)(nil),         // 9: google.protobuf.Empty
+	(*pb.RecordResponseList)(nil), // 10: global.RecordResponseList
+	(*pb.ResponseCatalog)(nil),    // 11: global.ResponseCatalog
+	(*pb.ResponseDelete)(nil),     // 12: global.ResponseDelete
 }
 var file_mp4_proto_depIdxs = []int32{
 	8,  // 0: mp4.ReqStartRecord.fragment:type_name -> google.protobuf.Duration
@@ -741,7 +692,7 @@ var file_mp4_proto_depIdxs = []int32{
 	2,  // 4: mp4.api.EventStart:input_type -> mp4.ReqEventRecord
 	4,  // 5: mp4.api.StartRecord:input_type -> mp4.ReqStartRecord
 	6,  // 6: mp4.api.StopRecord:input_type -> mp4.ReqStopRecord
-	10, // 7: mp4.api.List:output_type -> global.ResponseList
+	10, // 7: mp4.api.List:output_type -> global.RecordResponseList
 	11, // 8: mp4.api.Catalog:output_type -> global.ResponseCatalog
 	12, // 9: mp4.api.Delete:output_type -> global.ResponseDelete
 	3,  // 10: mp4.api.EventStart:output_type -> mp4.ResponseEventRecord

plugin/mp4/pb/mp4.pb.gw.go

@@ -330,7 +330,6 @@ func local_request_Api_StopRecord_0(ctx context.Context, marshaler runtime.Marsh
 // UnaryRPC     :call ApiServer directly.
 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
 // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterApiHandlerFromEndpoint instead.
-// GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.
 func RegisterApiHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ApiServer) error {
 
 	mux.Handle("GET", pattern_Api_List_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
@@ -489,21 +488,21 @@ func RegisterApiHandlerServer(ctx context.Context, mux *runtime.ServeMux, server
 // RegisterApiHandlerFromEndpoint is same as RegisterApiHandler but
 // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
 func RegisterApiHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
-	conn, err := grpc.NewClient(endpoint, opts...)
+	conn, err := grpc.DialContext(ctx, endpoint, opts...)
 	if err != nil {
 		return err
 	}
 	defer func() {
 		if err != nil {
 			if cerr := conn.Close(); cerr != nil {
-				grpclog.Errorf("Failed to close conn to %s: %v", endpoint, cerr)
+				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
 			}
 			return
 		}
 		go func() {
 			<-ctx.Done()
 			if cerr := conn.Close(); cerr != nil {
-				grpclog.Errorf("Failed to close conn to %s: %v", endpoint, cerr)
+				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
 			}
 		}()
 	}()
@@ -521,7 +520,7 @@ func RegisterApiHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.C
 // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ApiClient".
 // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ApiClient"
 // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
-// "ApiClient" to call the correct interceptors. This client ignores the HTTP middlewares.
+// "ApiClient" to call the correct interceptors.
 func RegisterApiHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ApiClient) error {
 
 	mux.Handle("GET", pattern_Api_List_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {

plugin/mp4/pb/mp4.proto

@@ -7,7 +7,7 @@ package mp4;
 option go_package="m7s.live/v5/plugin/mp4/pb";
 
 service api {
-  rpc List (ReqRecordList) returns (global.ResponseList) {
+  rpc List (ReqRecordList) returns (global.RecordResponseList) {
     option (google.api.http) = {
       get: "/mp4/api/list/{streamPath=**}"
     };

plugin/mp4/pb/mp4_grpc.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
 // - protoc-gen-go-grpc v1.5.1
-// - protoc             v5.28.3
+// - protoc             v5.29.3
 // source: mp4.proto
 
 package pb
@@ -33,7 +33,7 @@ const (
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type ApiClient interface {
-	List(ctx context.Context, in *ReqRecordList, opts ...grpc.CallOption) (*pb.ResponseList, error)
+	List(ctx context.Context, in *ReqRecordList, opts ...grpc.CallOption) (*pb.RecordResponseList, error)
 	Catalog(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*pb.ResponseCatalog, error)
 	Delete(ctx context.Context, in *ReqRecordDelete, opts ...grpc.CallOption) (*pb.ResponseDelete, error)
 	EventStart(ctx context.Context, in *ReqEventRecord, opts ...grpc.CallOption) (*ResponseEventRecord, error)
@@ -49,9 +49,9 @@ func NewApiClient(cc grpc.ClientConnInterface) ApiClient {
 	return &apiClient{cc}
 }
 
-func (c *apiClient) List(ctx context.Context, in *ReqRecordList, opts ...grpc.CallOption) (*pb.ResponseList, error) {
+func (c *apiClient) List(ctx context.Context, in *ReqRecordList, opts ...grpc.CallOption) (*pb.RecordResponseList, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	out := new(pb.ResponseList)
+	out := new(pb.RecordResponseList)
 	err := c.cc.Invoke(ctx, Api_List_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
@@ -113,7 +113,7 @@ func (c *apiClient) StopRecord(ctx context.Context, in *ReqStopRecord, opts ...g
 // All implementations must embed UnimplementedApiServer
 // for forward compatibility.
 type ApiServer interface {
-	List(context.Context, *ReqRecordList) (*pb.ResponseList, error)
+	List(context.Context, *ReqRecordList) (*pb.RecordResponseList, error)
 	Catalog(context.Context, *emptypb.Empty) (*pb.ResponseCatalog, error)
 	Delete(context.Context, *ReqRecordDelete) (*pb.ResponseDelete, error)
 	EventStart(context.Context, *ReqEventRecord) (*ResponseEventRecord, error)
@@ -129,7 +129,7 @@ type ApiServer interface {
 // pointer dereference when methods are called.
 type UnimplementedApiServer struct{}
 
-func (UnimplementedApiServer) List(context.Context, *ReqRecordList) (*pb.ResponseList, error) {
+func (UnimplementedApiServer) List(context.Context, *ReqRecordList) (*pb.RecordResponseList, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
 }
 func (UnimplementedApiServer) Catalog(context.Context, *emptypb.Empty) (*pb.ResponseCatalog, error) {

plugin/mp4/pkg/audio.go

@@ -0,0 +1,139 @@
+package mp4
+
+import (
+	"fmt"
+	"io"
+	"time"
+
+	"m7s.live/v5/pkg"
+	"m7s.live/v5/pkg/codec"
+	"m7s.live/v5/pkg/util"
+	"m7s.live/v5/plugin/mp4/pkg/box"
+)
+
+var _ pkg.IAVFrame = (*Audio)(nil)
+
+type Audio struct {
+	box.Sample
+	allocator *util.ScalableMemoryAllocator
+}
+
+// GetAllocator implements pkg.IAVFrame.
+func (a *Audio) GetAllocator() *util.ScalableMemoryAllocator {
+	return a.allocator
+}
+
+// SetAllocator implements pkg.IAVFrame.
+func (a *Audio) SetAllocator(allocator *util.ScalableMemoryAllocator) {
+	a.allocator = allocator
+}
+
+// Parse implements pkg.IAVFrame.
+func (a *Audio) Parse(t *pkg.AVTrack) error {
+	return nil
+}
+
+// ConvertCtx implements pkg.IAVFrame.
+func (a *Audio) ConvertCtx(ctx codec.ICodecCtx) (codec.ICodecCtx, pkg.IAVFrame, error) {
+	// 返回基础编解码器上下文，不进行转换
+	return ctx.GetBase(), nil, nil
+}
+
+// Demux implements pkg.IAVFrame.
+func (a *Audio) Demux(codecCtx codec.ICodecCtx) (any, error) {
+	if len(a.Data) == 0 {
+		return nil, fmt.Errorf("no audio data to demux")
+	}
+
+	// 创建内存对象
+	var result util.Memory
+	result.AppendOne(a.Data)
+
+	// 根据编解码器类型进行解复用
+	switch codecCtx.(type) {
+	case *codec.AACCtx:
+		// 对于 AAC，直接返回原始数据
+		return result, nil
+	case *codec.PCMACtx, *codec.PCMUCtx:
+		// 对于 PCM 格式，直接返回原始数据
+		return result, nil
+	default:
+		// 对于其他格式，也直接返回原始数据
+		return result, nil
+	}
+}
+
+// Mux implements pkg.IAVFrame.
+func (a *Audio) Mux(codecCtx codec.ICodecCtx, frame *pkg.AVFrame) {
+	// 从 AVFrame 复制数据到 MP4 Sample
+	a.KeyFrame = false // 音频帧通常不是关键帧
+	a.Timestamp = uint32(frame.Timestamp.Milliseconds())
+	a.CTS = uint32(frame.CTS.Milliseconds())
+
+	// 处理原始数据
+	if frame.Raw != nil {
+		switch rawData := frame.Raw.(type) {
+		case util.Memory: // 包括 pkg.AudioData (它是 util.Memory 的别名)
+			a.Data = rawData.ToBytes()
+			a.Size = len(a.Data)
+
+		case []byte:
+			// 直接复制字节数据
+			a.Data = rawData
+			a.Size = len(a.Data)
+
+		default:
+			// 对于其他类型，尝试转换为字节
+			a.Data = nil
+			a.Size = 0
+		}
+	} else {
+		a.Data = nil
+		a.Size = 0
+	}
+}
+
+// GetTimestamp implements pkg.IAVFrame.
+func (a *Audio) GetTimestamp() time.Duration {
+	return time.Duration(a.Timestamp) * time.Millisecond
+}
+
+// GetCTS implements pkg.IAVFrame.
+func (a *Audio) GetCTS() time.Duration {
+	return time.Duration(a.CTS) * time.Millisecond
+}
+
+// GetSize implements pkg.IAVFrame.
+func (a *Audio) GetSize() int {
+	return a.Size
+}
+
+// Recycle implements pkg.IAVFrame.
+func (a *Audio) Recycle() {
+	// 回收资源
+	if a.allocator != nil && a.Data != nil {
+		// 如果数据是通过分配器分配的，这里可以进行回收
+		// 由于我们使用的是复制的数据，这里暂时不需要特殊处理
+	}
+	a.Data = nil
+	a.Size = 0
+	a.KeyFrame = false
+	a.Timestamp = 0
+	a.CTS = 0
+	a.Offset = 0
+	a.Duration = 0
+}
+
+// String implements pkg.IAVFrame.
+func (a *Audio) String() string {
+	return fmt.Sprintf("MP4Audio[ts:%d, cts:%d, size:%d]",
+		a.Timestamp, a.CTS, a.Size)
+}
+
+// Dump implements pkg.IAVFrame.
+func (a *Audio) Dump(t byte, w io.Writer) {
+	// 输出数据到 writer
+	if a.Data != nil {
+		w.Write(a.Data)
+	}
+}

plugin/mp4/pkg/box/box.go

@@ -343,7 +343,25 @@ var (
 	TypeAUXV = f("auxv")
 	TypeHINT = f("hint")
 	TypeUDTA = f("udta")
-	TypeM7SP = f("m7sp") // Custom box type for M7S StreamPath
+
+	// Common metadata box types
+	TypeTITL      = f("©nam") // Title
+	TypeART       = f("©ART") // Artist/Author
+	TypeALB       = f("©alb") // Album
+	TypeDAY       = f("©day") // Date/Year
+	TypeCMT       = f("©cmt") // Comment/Description
+	TypeGEN       = f("©gen") // Genre
+	TypeCPRT      = f("cprt") // Copyright
+	TypeENCO      = f("©too") // Encoder/Tool
+	TypeWRT       = f("©wrt") // Writer/Composer
+	TypePRD       = f("©prd") // Producer
+	TypePRF       = f("©prf") // Performer
+	TypeGRP       = f("©grp") // Grouping
+	TypeLYR       = f("©lyr") // Lyrics
+	TypeKEYW      = f("keyw") // Keywords
+	TypeLOCI      = f("loci") // Location Information
+	TypeRTNG      = f("rtng") // Rating
+	TypeMETA_CUST = f("----") // Custom metadata (iTunes-style)
 )
 
 //	aligned(8) class Box (unsigned int(32) boxtype, optional unsigned int(8)[16] extended_type) {

plugin/mp4/pkg/box/metadata.go

@@ -0,0 +1,334 @@
+package box
+
+import (
+	"encoding/binary"
+	"io"
+	"time"
+)
+
+// Metadata holds various metadata information for MP4
+type Metadata struct {
+	Title     string            // 标题
+	Artist    string            // 艺术家/作者
+	Album     string            // 专辑
+	Date      string            // 日期
+	Comment   string            // 注释/描述
+	Genre     string            // 类型
+	Copyright string            // 版权信息
+	Encoder   string            // 编码器
+	Writer    string            // 作词者
+	Producer  string            // 制作人
+	Performer string            // 表演者
+	Grouping  string            // 分组
+	Lyrics    string            // 歌词
+	Keywords  string            // 关键词
+	Location  string            // 位置信息
+	Rating    uint8             // 评级 (0-5)
+	Custom    map[string]string // 自定义键值对
+}
+
+// Text Data Box - for storing text metadata
+type TextDataBox struct {
+	FullBox
+	Text string
+}
+
+// Metadata Data Box - for storing binary metadata with type indicator
+type MetadataDataBox struct {
+	FullBox
+	DataType uint32 // Data type indicator
+	Country  uint32 // Country code
+	Language uint32 // Language code
+	Data     []byte // Actual data
+}
+
+// Copyright Box
+type CopyrightBox struct {
+	FullBox
+	Language [3]byte
+	Notice   string
+}
+
+// Custom Metadata Box (iTunes-style ---- box)
+type CustomMetadataBox struct {
+	BaseBox
+	Mean string // Mean (namespace)
+	Name string // Name (key)
+	Data []byte // Data
+}
+
+// Create functions
+
+func CreateTextDataBox(boxType BoxType, text string) *TextDataBox {
+	return &TextDataBox{
+		FullBox: FullBox{
+			BaseBox: BaseBox{
+				typ:  boxType,
+				size: uint32(FullBoxLen + len(text)),
+			},
+			Version: 0,
+			Flags:   [3]byte{0, 0, 0},
+		},
+		Text: text,
+	}
+}
+
+func CreateMetadataDataBox(dataType uint32, data []byte) *MetadataDataBox {
+	return &MetadataDataBox{
+		FullBox: FullBox{
+			BaseBox: BaseBox{
+				typ:  f("data"),
+				size: uint32(FullBoxLen + 8 + len(data)), // 8 bytes for type+country+language
+			},
+			Version: 0,
+			Flags:   [3]byte{0, 0, 0},
+		},
+		DataType: dataType,
+		Country:  0,
+		Language: 0,
+		Data:     data,
+	}
+}
+
+func CreateCopyrightBox(language [3]byte, notice string) *CopyrightBox {
+	return &CopyrightBox{
+		FullBox: FullBox{
+			BaseBox: BaseBox{
+				typ:  TypeCPRT,
+				size: uint32(FullBoxLen + 3 + 1 + len(notice)), // 3 for language, 1 for null terminator
+			},
+			Version: 0,
+			Flags:   [3]byte{0, 0, 0},
+		},
+		Language: language,
+		Notice:   notice,
+	}
+}
+
+func CreateCustomMetadataBox(mean, name string, data []byte) *CustomMetadataBox {
+	size := uint32(BasicBoxLen + 4 + len(mean) + 4 + len(name) + len(data))
+	return &CustomMetadataBox{
+		BaseBox: BaseBox{
+			typ:  TypeMETA_CUST,
+			size: size,
+		},
+		Mean: mean,
+		Name: name,
+		Data: data,
+	}
+}
+
+// WriteTo methods
+
+func (box *TextDataBox) WriteTo(w io.Writer) (n int64, err error) {
+	nn, err := w.Write([]byte(box.Text))
+	return int64(nn), err
+}
+
+func (box *MetadataDataBox) WriteTo(w io.Writer) (n int64, err error) {
+	var tmp [8]byte
+	binary.BigEndian.PutUint32(tmp[0:4], box.DataType)
+	binary.BigEndian.PutUint32(tmp[4:8], box.Country)
+	// Language field is implicit zero
+
+	nn, err := w.Write(tmp[:8])
+	if err != nil {
+		return int64(nn), err
+	}
+	n = int64(nn)
+
+	nn, err = w.Write(box.Data)
+	return n + int64(nn), err
+}
+
+func (box *CopyrightBox) WriteTo(w io.Writer) (n int64, err error) {
+	// Write language code
+	nn, err := w.Write(box.Language[:])
+	if err != nil {
+		return int64(nn), err
+	}
+	n = int64(nn)
+
+	// Write notice + null terminator
+	nn, err = w.Write([]byte(box.Notice + "\x00"))
+	return n + int64(nn), err
+}
+
+func (box *CustomMetadataBox) WriteTo(w io.Writer) (n int64, err error) {
+	var tmp [4]byte
+
+	// Write mean length + mean
+	binary.BigEndian.PutUint32(tmp[:], uint32(len(box.Mean)))
+	nn, err := w.Write(tmp[:])
+	if err != nil {
+		return int64(nn), err
+	}
+	n = int64(nn)
+
+	nn, err = w.Write([]byte(box.Mean))
+	if err != nil {
+		return n + int64(nn), err
+	}
+	n += int64(nn)
+
+	// Write name length + name
+	binary.BigEndian.PutUint32(tmp[:], uint32(len(box.Name)))
+	nn, err = w.Write(tmp[:])
+	if err != nil {
+		return n + int64(nn), err
+	}
+	n += int64(nn)
+
+	nn, err = w.Write([]byte(box.Name))
+	if err != nil {
+		return n + int64(nn), err
+	}
+	n += int64(nn)
+
+	// Write data
+	nn, err = w.Write(box.Data)
+	return n + int64(nn), err
+}
+
+// Unmarshal methods
+
+func (box *TextDataBox) Unmarshal(buf []byte) (IBox, error) {
+	box.Text = string(buf)
+	return box, nil
+}
+
+func (box *MetadataDataBox) Unmarshal(buf []byte) (IBox, error) {
+	if len(buf) < 8 {
+		return nil, io.ErrShortBuffer
+	}
+
+	box.DataType = binary.BigEndian.Uint32(buf[0:4])
+	box.Country = binary.BigEndian.Uint32(buf[4:8])
+	box.Data = buf[8:]
+	return box, nil
+}
+
+func (box *CopyrightBox) Unmarshal(buf []byte) (IBox, error) {
+	if len(buf) < 4 {
+		return nil, io.ErrShortBuffer
+	}
+
+	copy(box.Language[:], buf[0:3])
+	// Find null terminator
+	for i := 3; i < len(buf); i++ {
+		if buf[i] == 0 {
+			box.Notice = string(buf[3:i])
+			break
+		}
+	}
+	if box.Notice == "" && len(buf) > 3 {
+		box.Notice = string(buf[3:])
+	}
+	return box, nil
+}
+
+func (box *CustomMetadataBox) Unmarshal(buf []byte) (IBox, error) {
+	if len(buf) < 8 {
+		return nil, io.ErrShortBuffer
+	}
+
+	offset := 0
+
+	// Read mean length + mean
+	meanLen := binary.BigEndian.Uint32(buf[offset:])
+	offset += 4
+	if offset+int(meanLen) > len(buf) {
+		return nil, io.ErrShortBuffer
+	}
+	box.Mean = string(buf[offset : offset+int(meanLen)])
+	offset += int(meanLen)
+
+	// Read name length + name
+	if offset+4 > len(buf) {
+		return nil, io.ErrShortBuffer
+	}
+	nameLen := binary.BigEndian.Uint32(buf[offset:])
+	offset += 4
+	if offset+int(nameLen) > len(buf) {
+		return nil, io.ErrShortBuffer
+	}
+	box.Name = string(buf[offset : offset+int(nameLen)])
+	offset += int(nameLen)
+
+	// Read remaining data
+	box.Data = buf[offset:]
+	return box, nil
+}
+
+// Create metadata entries from Metadata struct
+func CreateMetadataEntries(metadata *Metadata) []IBox {
+	var entries []IBox
+
+	// Standard text metadata
+	if metadata.Title != "" {
+		entries = append(entries, CreateTextDataBox(TypeTITL, metadata.Title))
+	}
+	if metadata.Artist != "" {
+		entries = append(entries, CreateTextDataBox(TypeART, metadata.Artist))
+	}
+	if metadata.Album != "" {
+		entries = append(entries, CreateTextDataBox(TypeALB, metadata.Album))
+	}
+	if metadata.Date != "" {
+		entries = append(entries, CreateTextDataBox(TypeDAY, metadata.Date))
+	}
+	if metadata.Comment != "" {
+		entries = append(entries, CreateTextDataBox(TypeCMT, metadata.Comment))
+	}
+	if metadata.Genre != "" {
+		entries = append(entries, CreateTextDataBox(TypeGEN, metadata.Genre))
+	}
+	if metadata.Encoder != "" {
+		entries = append(entries, CreateTextDataBox(TypeENCO, metadata.Encoder))
+	}
+	if metadata.Writer != "" {
+		entries = append(entries, CreateTextDataBox(TypeWRT, metadata.Writer))
+	}
+	if metadata.Producer != "" {
+		entries = append(entries, CreateTextDataBox(TypePRD, metadata.Producer))
+	}
+	if metadata.Performer != "" {
+		entries = append(entries, CreateTextDataBox(TypePRF, metadata.Performer))
+	}
+	if metadata.Grouping != "" {
+		entries = append(entries, CreateTextDataBox(TypeGRP, metadata.Grouping))
+	}
+	if metadata.Lyrics != "" {
+		entries = append(entries, CreateTextDataBox(TypeLYR, metadata.Lyrics))
+	}
+	if metadata.Keywords != "" {
+		entries = append(entries, CreateTextDataBox(TypeKEYW, metadata.Keywords))
+	}
+	if metadata.Location != "" {
+		entries = append(entries, CreateTextDataBox(TypeLOCI, metadata.Location))
+	}
+
+	// Copyright (special format)
+	if metadata.Copyright != "" {
+		entries = append(entries, CreateCopyrightBox([3]byte{'u', 'n', 'd'}, metadata.Copyright))
+	}
+
+	// Custom metadata
+	for key, value := range metadata.Custom {
+		entries = append(entries, CreateCustomMetadataBox("live.m7s.custom", key, []byte(value)))
+	}
+
+	return entries
+}
+
+// Helper function to create current date string
+func GetCurrentDateString() string {
+	return time.Now().Format("2006-01-02")
+}
+
+func init() {
+	RegisterBox[*TextDataBox](TypeTITL, TypeART, TypeALB, TypeDAY, TypeCMT, TypeGEN, TypeENCO, TypeWRT, TypePRD, TypePRF, TypeGRP, TypeLYR, TypeKEYW, TypeLOCI, TypeRTNG)
+	RegisterBox[*MetadataDataBox](f("data"))
+	RegisterBox[*CopyrightBox](TypeCPRT)
+	RegisterBox[*CustomMetadataBox](TypeMETA_CUST)
+}

plugin/mp4/pkg/box/udta.go

@@ -12,12 +12,6 @@ type UserDataBox struct {
 	Entries []IBox
 }
 
-// Custom metadata box for storing stream path
-type StreamPathBox struct {
-	FullBox
-	StreamPath string
-}
-
 // Create a new User Data Box
 func CreateUserDataBox(entries ...IBox) *UserDataBox {
 	size := uint32(BasicBoxLen)
@@ -33,21 +27,6 @@ func CreateUserDataBox(entries ...IBox) *UserDataBox {
 	}
 }
 
-// Create a new StreamPath Box
-func CreateStreamPathBox(streamPath string) *StreamPathBox {
-	return &StreamPathBox{
-		FullBox: FullBox{
-			BaseBox: BaseBox{
-				typ:  TypeM7SP, // Custom box type for M7S StreamPath
-				size: uint32(FullBoxLen + len(streamPath)),
-			},
-			Version: 0,
-			Flags:   [3]byte{0, 0, 0},
-		},
-		StreamPath: streamPath,
-	}
-}
-
 // WriteTo writes the UserDataBox to the given writer
 func (box *UserDataBox) WriteTo(w io.Writer) (n int64, err error) {
 	return WriteTo(w, box.Entries...)
@@ -69,19 +48,6 @@ func (box *UserDataBox) Unmarshal(buf []byte) (IBox, error) {
 	return box, nil
 }
 
-// WriteTo writes the StreamPathBox to the given writer
-func (box *StreamPathBox) WriteTo(w io.Writer) (n int64, err error) {
-	nn, err := w.Write([]byte(box.StreamPath))
-	return int64(nn), err
-}
-
-// Unmarshal parses the given buffer into a StreamPathBox
-func (box *StreamPathBox) Unmarshal(buf []byte) (IBox, error) {
-	box.StreamPath = string(buf)
-	return box, nil
-}
-
 func init() {
 	RegisterBox[*UserDataBox](TypeUDTA)
-	RegisterBox[*StreamPathBox](TypeM7SP)
 }

plugin/mp4/pkg/demux-range.go

@@ -2,25 +2,31 @@ package mp4
 
 import (
 	"context"
+	"log/slog"
 	"os"
 	"time"
 
+	"github.com/deepch/vdk/codec/aacparser"
+	"github.com/deepch/vdk/codec/h264parser"
+	"github.com/deepch/vdk/codec/h265parser"
 	"m7s.live/v5"
+	"m7s.live/v5/pkg"
+	"m7s.live/v5/pkg/codec"
+	"m7s.live/v5/pkg/util"
 	"m7s.live/v5/plugin/mp4/pkg/box"
 )
 
 type DemuxerRange struct {
-	StartTime, EndTime time.Time
-	Streams            []m7s.RecordStream
-	OnAudioExtraData   func(codec box.MP4_CODEC_TYPE, data []byte) error
-	OnVideoExtraData   func(codec box.MP4_CODEC_TYPE, data []byte) error
-	OnAudioSample      func(codec box.MP4_CODEC_TYPE, sample box.Sample) error
-	OnVideoSample      func(codec box.MP4_CODEC_TYPE, sample box.Sample) error
+	*slog.Logger
+	StartTime, EndTime     time.Time
+	Streams                []m7s.RecordStream
+	AudioTrack, VideoTrack *pkg.AVTrack
 }
 
-func (d *DemuxerRange) Demux(ctx context.Context) error {
+func (d *DemuxerRange) Demux(ctx context.Context, onAudio func(*Audio) error, onVideo func(*Video) error) error {
 	var ts, tsOffset int64
-
+	allocator := util.NewScalableMemoryAllocator(1 << 10)
+	defer allocator.Recycle()
 	for _, stream := range d.Streams {
 		// 检查流的时间范围是否在指定范围内
 		if stream.EndTime.Before(d.StartTime) || stream.StartTime.After(d.EndTime) {
@@ -42,20 +48,84 @@ func (d *DemuxerRange) Demux(ctx context.Context) error {
 		// 处理每个轨道的额外数据 (序列头)
 		for _, track := range demuxer.Tracks {
 			switch track.Cid {
-			case box.MP4_CODEC_H264, box.MP4_CODEC_H265:
-				if d.OnVideoExtraData != nil {
-					err := d.OnVideoExtraData(track.Cid, track.ExtraData)
-					if err != nil {
-						return err
+			case box.MP4_CODEC_H264:
+				var h264Ctx codec.H264Ctx
+				h264Ctx.CodecData, err = h264parser.NewCodecDataFromAVCDecoderConfRecord(track.ExtraData)
+				if err == nil {
+					if d.VideoTrack == nil {
+						d.VideoTrack = &pkg.AVTrack{
+							ICodecCtx: &h264Ctx,
+							RingWriter: &pkg.RingWriter{
+								Ring: util.NewRing[pkg.AVFrame](1),
+							}}
+						d.VideoTrack.Logger = d.With("track", "video")
+					} else {
+						// 如果已经有视频轨道，使用现有的轨道
+						d.VideoTrack.ICodecCtx = &h264Ctx
 					}
 				}
-			case box.MP4_CODEC_AAC, box.MP4_CODEC_G711A, box.MP4_CODEC_G711U:
-				if d.OnAudioExtraData != nil {
-					err := d.OnAudioExtraData(track.Cid, track.ExtraData)
-					if err != nil {
-						return err
+			case box.MP4_CODEC_H265:
+				var h265Ctx codec.H265Ctx
+				h265Ctx.CodecData, err = h265parser.NewCodecDataFromAVCDecoderConfRecord(track.ExtraData)
+				if err == nil {
+					if d.VideoTrack == nil {
+						d.VideoTrack = &pkg.AVTrack{
+							ICodecCtx: &h265Ctx,
+							RingWriter: &pkg.RingWriter{
+								Ring: util.NewRing[pkg.AVFrame](1),
+							}}
+						d.VideoTrack.Logger = d.With("track", "video")
+					} else {
+						// 如果已经有视频轨道，使用现有的轨道
+						d.VideoTrack.ICodecCtx = &h265Ctx
 					}
 				}
+			case box.MP4_CODEC_AAC:
+				var aacCtx codec.AACCtx
+				aacCtx.CodecData, err = aacparser.NewCodecDataFromMPEG4AudioConfigBytes(track.ExtraData)
+				if err == nil {
+					if d.AudioTrack == nil {
+						d.AudioTrack = &pkg.AVTrack{
+							ICodecCtx: &aacCtx,
+							RingWriter: &pkg.RingWriter{
+								Ring: util.NewRing[pkg.AVFrame](1),
+							}}
+						d.AudioTrack.Logger = d.With("track", "audio")
+					} else {
+						// 如果已经有音频轨道，使用现有的轨道
+						d.AudioTrack.ICodecCtx = &aacCtx
+					}
+				}
+			case box.MP4_CODEC_G711A:
+				if d.AudioTrack == nil {
+					d.AudioTrack = &pkg.AVTrack{
+						ICodecCtx: &codec.PCMACtx{
+							AudioCtx: codec.AudioCtx{
+								SampleRate: 8000,
+								Channels:   1,
+								SampleSize: 16,
+							},
+						},
+						RingWriter: &pkg.RingWriter{
+							Ring: util.NewRing[pkg.AVFrame](1),
+						}}
+					d.AudioTrack.Logger = d.With("track", "audio")
+				}
+			case box.MP4_CODEC_G711U:
+				if d.AudioTrack == nil {
+					d.AudioTrack = &pkg.AVTrack{
+						ICodecCtx: &codec.PCMUCtx{
+							AudioCtx: codec.AudioCtx{
+								SampleRate: 8000,
+								Channels:   1,
+								SampleSize: 16,
+							},
+						},
+						RingWriter: &pkg.RingWriter{
+							Ring: util.NewRing[pkg.AVFrame](1),
+						}}
+					d.AudioTrack.Logger = d.With("track", "audio")
+				}
 			}
 		}
 
@@ -101,21 +171,50 @@ func (d *DemuxerRange) Demux(ctx context.Context) error {
 			// 根据轨道类型调用相应的回调函数
 			switch track.Cid {
 			case box.MP4_CODEC_H264, box.MP4_CODEC_H265:
-				if d.OnVideoSample != nil {
-					err := d.OnVideoSample(track.Cid, sample)
-					if err != nil {
-						return err
-					}
+				if err := onVideo(&Video{
+					Sample:    sample,
+					allocator: allocator,
+				}); err != nil {
+					return err
 				}
 			case box.MP4_CODEC_AAC, box.MP4_CODEC_G711A, box.MP4_CODEC_G711U:
-				if d.OnAudioSample != nil {
-					err := d.OnAudioSample(track.Cid, sample)
-					if err != nil {
-						return err
-					}
+				if err := onAudio(&Audio{
+					Sample:    sample,
+					allocator: allocator,
+				}); err != nil {
+					return err
 				}
 			}
 		}
 	}
 	return nil
 }
+
+type DemuxerConverterRange[TA pkg.IAVFrame, TV pkg.IAVFrame] struct {
+	DemuxerRange
+	audioConverter *pkg.AVFrameConvert[TA]
+	videoConverter *pkg.AVFrameConvert[TV]
+}
+
+func (d *DemuxerConverterRange[TA, TV]) Demux(ctx context.Context, onAudio func(TA) error, onVideo func(TV) error) error {
+	d.DemuxerRange.Demux(ctx, func(audio *Audio) error {
+		if d.audioConverter == nil {
+			d.audioConverter = pkg.NewAVFrameConvert[TA](d.AudioTrack, nil)
+		}
+		target, err := d.audioConverter.Convert(audio)
+		if err == nil {
+			err = onAudio(target)
+		}
+		return err
+	}, func(video *Video) error {
+		if d.videoConverter == nil {
+			d.videoConverter = pkg.NewAVFrameConvert[TV](d.VideoTrack, nil)
+		}
+		target, err := d.videoConverter.Convert(video)
+		if err == nil {
+			err = onVideo(target)
+		}
+		return err
+	})
+	return nil
+}

plugin/mp4/pkg/demuxer.go

@@ -382,23 +382,20 @@ func (d *Demuxer) ReadSample(yield func(*Track, Sample) bool) {
 		maxdts := int64(-1)
 		minTsSample := Sample{Timestamp: uint32(maxdts)}
 		var whichTrack *Track
-		whichTracki := 0
-		for i, track := range d.Tracks {
-			idx := d.ReadSampleIdx[i]
+		for _, track := range d.Tracks {
+			idx := d.ReadSampleIdx[track.TrackId-1]
 			if int(idx) == len(track.Samplelist) {
 				continue
 			}
 			if whichTrack == nil {
 				minTsSample = track.Samplelist[idx]
 				whichTrack = track
-				whichTracki = i
 			} else {
 				dts1 := uint64(minTsSample.Timestamp) * uint64(d.moov.MVHD.Timescale) / uint64(whichTrack.Timescale)
 				dts2 := uint64(track.Samplelist[idx].Timestamp) * uint64(d.moov.MVHD.Timescale) / uint64(track.Timescale)
 				if dts1 > dts2 {
 					minTsSample = track.Samplelist[idx]
 					whichTrack = track
-					whichTracki = i
 				}
 			}
 			// subSample := d.readSubSample(idx, whichTrack)
@@ -407,7 +404,7 @@ func (d *Demuxer) ReadSample(yield func(*Track, Sample) bool) {
 			return
 		}
 
-		d.ReadSampleIdx[whichTracki]++
+		d.ReadSampleIdx[whichTrack.TrackId-1]++
 		if !yield(whichTrack, minTsSample) {
 			return
 		}
@@ -418,21 +415,18 @@ func (d *Demuxer) RangeSample(yield func(*Track, *Sample) bool) {
 	for {
 		var minTsSample *Sample
 		var whichTrack *Track
-		whichTracki := 0
-		for i, track := range d.Tracks {
-			idx := d.ReadSampleIdx[i]
+		for _, track := range d.Tracks {
+			idx := d.ReadSampleIdx[track.TrackId-1]
 			if int(idx) == len(track.Samplelist) {
 				continue
 			}
 			if whichTrack == nil {
 				minTsSample = &track.Samplelist[idx]
 				whichTrack = track
-				whichTracki = i
 			} else {
 				if minTsSample.Offset > track.Samplelist[idx].Offset {
 					minTsSample = &track.Samplelist[idx]
 					whichTrack = track
-					whichTracki = i
 				}
 			}
 			// subSample := d.readSubSample(idx, whichTrack)
@@ -440,7 +434,7 @@ func (d *Demuxer) RangeSample(yield func(*Track, *Sample) bool) {
 		if minTsSample == nil {
 			return
 		}
-		d.ReadSampleIdx[whichTracki]++
+		d.ReadSampleIdx[whichTrack.TrackId-1]++
 		if !yield(whichTrack, minTsSample) {
 			return
 		}

plugin/mp4/pkg/muxer.go

@@ -29,7 +29,8 @@ type (
 		moov         IBox
 		mdatOffset   uint64
 		mdatSize     uint64
-		StreamPath   string // Added to store the stream path
+		StreamPath   string    // Added to store the stream path
+		Metadata     *Metadata // 添加元数据支持
 	}
 )
 
@@ -52,6 +53,7 @@ func NewMuxer(flag Flag) *Muxer {
 		Tracks:         make(map[uint32]*Track),
 		Flag:           flag,
 		fragDuration:   2000,
+		Metadata:       &Metadata{Custom: make(map[string]string)},
 	}
 }
 
@@ -59,6 +61,8 @@ func NewMuxer(flag Flag) *Muxer {
 func NewMuxerWithStreamPath(flag Flag, streamPath string) *Muxer {
 	muxer := NewMuxer(flag)
 	muxer.StreamPath = streamPath
+	muxer.Metadata.Producer = "M7S Live"
+	muxer.Metadata.Album = streamPath
 	return muxer
 }
 
@@ -232,10 +236,10 @@ func (m *Muxer) MakeMoov() IBox {
 		children = append(children, m.makeMvex())
 	}
 
-	// Add user data box with stream path if available
-	if m.StreamPath != "" {
-		streamPathBox := CreateStreamPathBox(m.StreamPath)
-		udta := CreateUserDataBox(streamPathBox)
+	// Add user data box with metadata if available
+	metadataEntries := CreateMetadataEntries(m.Metadata)
+	if len(metadataEntries) > 0 {
+		udta := CreateUserDataBox(metadataEntries...)
 		children = append(children, udta)
 	}
 
@@ -365,3 +369,82 @@ func (m *Muxer) WriteTrailer(file *os.File) (err error) {
 func (m *Muxer) SetFragmentDuration(duration uint32) {
 	m.fragDuration = duration
 }
+
+// SetMetadata sets the metadata for the MP4 file
+func (m *Muxer) SetMetadata(metadata *Metadata) {
+	m.Metadata = metadata
+	if metadata.Custom == nil {
+		metadata.Custom = make(map[string]string)
+	}
+}
+
+// SetTitle sets the title metadata
+func (m *Muxer) SetTitle(title string) {
+	m.Metadata.Title = title
+}
+
+// SetArtist sets the artist/author metadata
+func (m *Muxer) SetArtist(artist string) {
+	m.Metadata.Artist = artist
+}
+
+// SetAlbum sets the album metadata
+func (m *Muxer) SetAlbum(album string) {
+	m.Metadata.Album = album
+}
+
+// SetComment sets the comment/description metadata
+func (m *Muxer) SetComment(comment string) {
+	m.Metadata.Comment = comment
+}
+
+// SetGenre sets the genre metadata
+func (m *Muxer) SetGenre(genre string) {
+	m.Metadata.Genre = genre
+}
+
+// SetCopyright sets the copyright metadata
+func (m *Muxer) SetCopyright(copyright string) {
+	m.Metadata.Copyright = copyright
+}
+
+// SetEncoder sets the encoder metadata
+func (m *Muxer) SetEncoder(encoder string) {
+	m.Metadata.Encoder = encoder
+}
+
+// SetDate sets the date metadata (format: YYYY-MM-DD)
+func (m *Muxer) SetDate(date string) {
+	m.Metadata.Date = date
+}
+
+// SetCurrentDate sets the date metadata to current date
+func (m *Muxer) SetCurrentDate() {
+	m.Metadata.Date = GetCurrentDateString()
+}
+
+// AddCustomMetadata adds custom key-value metadata
+func (m *Muxer) AddCustomMetadata(key, value string) {
+	if m.Metadata.Custom == nil {
+		m.Metadata.Custom = make(map[string]string)
+	}
+	m.Metadata.Custom[key] = value
+}
+
+// SetKeywords sets the keywords metadata
+func (m *Muxer) SetKeywords(keywords string) {
+	m.Metadata.Keywords = keywords
+}
+
+// SetLocation sets the location metadata
+func (m *Muxer) SetLocation(location string) {
+	m.Metadata.Location = location
+}
+
+// SetRating sets the rating metadata (0-5)
+func (m *Muxer) SetRating(rating uint8) {
+	if rating > 5 {
+		rating = 5
+	}
+	m.Metadata.Rating = rating
+}

plugin/mp4/pkg/pull-httpfile.go

@@ -6,11 +6,13 @@ import (
 	"strings"
 	"time"
 
+	"github.com/deepch/vdk/codec/aacparser"
+	"github.com/deepch/vdk/codec/h264parser"
+	"github.com/deepch/vdk/codec/h265parser"
 	m7s "m7s.live/v5"
 	"m7s.live/v5/pkg/codec"
 	"m7s.live/v5/pkg/util"
 	"m7s.live/v5/plugin/mp4/pkg/box"
-	rtmp "m7s.live/v5/plugin/rtmp/pkg"
 )
 
 type HTTPReader struct {
@@ -51,20 +53,27 @@ func (p *HTTPReader) Run() (err error) {
 	for _, track := range demuxer.Tracks {
 		switch track.Cid {
 		case box.MP4_CODEC_H264:
-			var sequence rtmp.RTMPVideo
-			sequence.SetAllocator(allocator)
-			sequence.Append([]byte{0x17, 0x00, 0x00, 0x00, 0x00}, track.ExtraData)
-			err = publisher.WriteVideo(&sequence)
+			var h264Ctx codec.H264Ctx
+			h264Ctx.CodecData, err = h264parser.NewCodecDataFromAVCDecoderConfRecord(track.ExtraData)
+			if err == nil {
+				publisher.SetCodecCtx(&h264Ctx, &Video{})
+			}
 		case box.MP4_CODEC_H265:
-			var sequence rtmp.RTMPVideo
-			sequence.SetAllocator(allocator)
-			sequence.Append([]byte{0b1001_0000 | rtmp.PacketTypeSequenceStart}, codec.FourCC_H265[:], track.ExtraData)
-			err = publisher.WriteVideo(&sequence)
+			var h265Ctx codec.H265Ctx
+			h265Ctx.CodecData, err = h265parser.NewCodecDataFromAVCDecoderConfRecord(track.ExtraData)
+			if err == nil {
+				publisher.SetCodecCtx(&h265Ctx, &Video{
+					allocator: allocator,
+				})
+			}
 		case box.MP4_CODEC_AAC:
-			var sequence rtmp.RTMPAudio
-			sequence.SetAllocator(allocator)
-			sequence.Append([]byte{0xaf, 0x00}, track.ExtraData)
-			err = publisher.WriteAudio(&sequence)
+			var aacCtx codec.AACCtx
+			aacCtx.CodecData, err = aacparser.NewCodecDataFromMPEG4AudioConfigBytes(track.ExtraData)
+			if err == nil {
+				publisher.SetCodecCtx(&aacCtx, &Audio{
+					allocator: allocator,
+				})
+			}
 		}
 	}
 
@@ -92,56 +101,44 @@ func (p *HTTPReader) Run() (err error) {
 				allocator.Free(sample.Data)
 				return
 			}
+			fixTimestamp := uint32(uint64(sample.Timestamp)*1000/uint64(track.Timescale) + timestampOffset)
 			switch track.Cid {
 			case box.MP4_CODEC_H264:
-				var videoFrame rtmp.RTMPVideo
-				videoFrame.SetAllocator(allocator)
-				videoFrame.CTS = sample.CTS
-				videoFrame.Timestamp = uint32(uint64(sample.Timestamp)*1000/uint64(track.Timescale) + timestampOffset)
-				videoFrame.AppendOne([]byte{util.Conditional[byte](sample.KeyFrame, 0x17, 0x27), 0x01, byte(videoFrame.CTS >> 24), byte(videoFrame.CTS >> 8), byte(videoFrame.CTS)})
-				videoFrame.AddRecycleBytes(sample.Data)
+				var videoFrame = Video{
+					Sample:    sample,
+					allocator: allocator,
+				}
+				videoFrame.Timestamp = fixTimestamp
 				err = publisher.WriteVideo(&videoFrame)
 			case box.MP4_CODEC_H265:
-				var videoFrame rtmp.RTMPVideo
-				videoFrame.SetAllocator(allocator)
-				videoFrame.CTS = uint32(sample.CTS)
-				videoFrame.Timestamp = uint32(uint64(sample.Timestamp)*1000/uint64(track.Timescale) + timestampOffset)
-				var head []byte
-				var b0 byte = 0b1010_0000
-				if sample.KeyFrame {
-					b0 = 0b1001_0000
+				var videoFrame = Video{
+					Sample:    sample,
+					allocator: allocator,
 				}
-				if videoFrame.CTS == 0 {
-					head = videoFrame.NextN(5)
-					head[0] = b0 | rtmp.PacketTypeCodedFramesX
-				} else {
-					head = videoFrame.NextN(8)
-					head[0] = b0 | rtmp.PacketTypeCodedFrames
-					util.PutBE(head[5:8], videoFrame.CTS) // cts
-				}
-				copy(head[1:], codec.FourCC_H265[:])
-				videoFrame.AddRecycleBytes(sample.Data)
+				videoFrame.Timestamp = fixTimestamp
 				err = publisher.WriteVideo(&videoFrame)
 			case box.MP4_CODEC_AAC:
-				var audioFrame rtmp.RTMPAudio
-				audioFrame.SetAllocator(allocator)
-				audioFrame.Timestamp = uint32(uint64(sample.Timestamp)*1000/uint64(track.Timescale) + timestampOffset)
-				audioFrame.AppendOne([]byte{0xaf, 0x01})
-				audioFrame.AddRecycleBytes(sample.Data)
+				var audioFrame = Audio{
+					Sample:    sample,
+					allocator: allocator,
+				}
+				audioFrame.Timestamp = fixTimestamp
 				err = publisher.WriteAudio(&audioFrame)
 			case box.MP4_CODEC_G711A:
-				var audioFrame rtmp.RTMPAudio
-				audioFrame.SetAllocator(allocator)
-				audioFrame.Timestamp = uint32(uint64(sample.Timestamp)*1000/uint64(track.Timescale) + timestampOffset)
-				audioFrame.AppendOne([]byte{0x72})
-				audioFrame.AddRecycleBytes(sample.Data)
+				var audioFrame = Audio{
+					Sample:    sample,
+					allocator: allocator,
+				}
+				audioFrame.Timestamp = fixTimestamp
 				err = publisher.WriteAudio(&audioFrame)
 			case box.MP4_CODEC_G711U:
-				var audioFrame rtmp.RTMPAudio
+				var audioFrame = Audio{
+					Sample:    sample,
+					allocator: allocator,
+				}
+				audioFrame.Sample = sample
 				audioFrame.SetAllocator(allocator)
-				audioFrame.Timestamp = uint32(uint64(sample.Timestamp)*1000/uint64(track.Timescale) + timestampOffset)
-				audioFrame.AppendOne([]byte{0x82})
-				audioFrame.AddRecycleBytes(sample.Data)
+				audioFrame.Timestamp = fixTimestamp
 				err = publisher.WriteAudio(&audioFrame)
 			}
 		}

plugin/mp4/pkg/pull-recorder.go

@@ -6,18 +6,14 @@ import (
 
 	m7s "m7s.live/v5"
 	"m7s.live/v5/pkg"
-	"m7s.live/v5/pkg/codec"
 	"m7s.live/v5/pkg/config"
 	"m7s.live/v5/pkg/task"
 	"m7s.live/v5/pkg/util"
-	"m7s.live/v5/plugin/mp4/pkg/box"
-	rtmp "m7s.live/v5/plugin/rtmp/pkg"
 )
 
 type (
 	RecordReader struct {
 		m7s.RecordFilePuller
-		demuxer *Demuxer
 	}
 )
 
@@ -53,125 +49,9 @@ func (p *RecordReader) Run() (err error) {
 	var tsOffset int64 // 时间戳偏移量
 
 	// 创建可复用的 DemuxerRange 实例
-	demuxerRange := &DemuxerRange{}
-	// 设置音视频额外数据回调（序列头）
-	demuxerRange.OnVideoExtraData = func(codecType box.MP4_CODEC_TYPE, data []byte) error {
-		switch codecType {
-		case box.MP4_CODEC_H264:
-			var sequence rtmp.RTMPVideo
-			sequence.Append([]byte{0x17, 0x00, 0x00, 0x00, 0x00}, data)
-			err = publisher.WriteVideo(&sequence)
-		case box.MP4_CODEC_H265:
-			var sequence rtmp.RTMPVideo
-			sequence.Append([]byte{0b1001_0000 | rtmp.PacketTypeSequenceStart}, codec.FourCC_H265[:], data)
-			err = publisher.WriteVideo(&sequence)
-		}
-		return err
-	}
-
-	demuxerRange.OnAudioExtraData = func(codecType box.MP4_CODEC_TYPE, data []byte) error {
-		if codecType == box.MP4_CODEC_AAC {
-			var sequence rtmp.RTMPAudio
-			sequence.Append([]byte{0xaf, 0x00}, data)
-			err = publisher.WriteAudio(&sequence)
-		}
-		return err
-	}
-
-	// 设置视频样本回调
-	demuxerRange.OnVideoSample = func(codecType box.MP4_CODEC_TYPE, sample box.Sample) error {
-		if publisher.Paused != nil {
-			publisher.Paused.Await()
-		}
-
-		// 检查是否需要跳转
-		if needSeek, seekErr := p.CheckSeek(); seekErr != nil {
-			return seekErr
-		} else if needSeek {
-			return pkg.ErrSkip
-		}
-
-		// 简化的时间戳处理
-		if int64(sample.Timestamp)+tsOffset < 0 {
-			ts = 0
-		} else {
-			ts = int64(sample.Timestamp) + tsOffset
-		}
-
-		// 更新实时时间
-		realTime = time.Now() // 这里可以根据需要调整为更精确的时间计算
-
-		// 根据编解码器类型处理视频帧
-		switch codecType {
-		case box.MP4_CODEC_H264:
-			var videoFrame rtmp.RTMPVideo
-			videoFrame.CTS = sample.CTS
-			videoFrame.Timestamp = uint32(ts)
-			videoFrame.Append([]byte{util.Conditional[byte](sample.KeyFrame, 0x17, 0x27), 0x01, byte(videoFrame.CTS >> 24), byte(videoFrame.CTS >> 8), byte(videoFrame.CTS)}, sample.Data)
-			err = publisher.WriteVideo(&videoFrame)
-		case box.MP4_CODEC_H265:
-			var videoFrame rtmp.RTMPVideo
-			videoFrame.CTS = sample.CTS
-			videoFrame.Timestamp = uint32(ts)
-			var head []byte
-			var b0 byte = 0b1010_0000
-			if sample.KeyFrame {
-				b0 = 0b1001_0000
-			}
-			if videoFrame.CTS == 0 {
-				head = videoFrame.NextN(5)
-				head[0] = b0 | rtmp.PacketTypeCodedFramesX
-			} else {
-				head = videoFrame.NextN(8)
-				head[0] = b0 | rtmp.PacketTypeCodedFrames
-				util.PutBE(head[5:8], videoFrame.CTS) // cts
-			}
-			copy(head[1:], codec.FourCC_H265[:])
-			videoFrame.AppendOne(sample.Data)
-			err = publisher.WriteVideo(&videoFrame)
-		}
-		return err
-	}
-
-	// 设置音频样本回调
-	demuxerRange.OnAudioSample = func(codecType box.MP4_CODEC_TYPE, sample box.Sample) error {
-		if publisher.Paused != nil {
-			publisher.Paused.Await()
-		}
-
-		// 检查是否需要跳转
-		if needSeek, seekErr := p.CheckSeek(); seekErr != nil {
-			return seekErr
-		} else if needSeek {
-			return pkg.ErrSkip
-		}
-
-		// 简化的时间戳处理
-		if int64(sample.Timestamp)+tsOffset < 0 {
-			ts = 0
-		} else {
-			ts = int64(sample.Timestamp) + tsOffset
-		}
-
-		// 根据编解码器类型处理音频帧
-		switch codecType {
-		case box.MP4_CODEC_AAC:
-			var audioFrame rtmp.RTMPAudio
-			audioFrame.Timestamp = uint32(ts)
-			audioFrame.Append([]byte{0xaf, 0x01}, sample.Data)
-			err = publisher.WriteAudio(&audioFrame)
-		case box.MP4_CODEC_G711A:
-			var audioFrame rtmp.RTMPAudio
-			audioFrame.Timestamp = uint32(ts)
-			audioFrame.Append([]byte{0x72}, sample.Data)
-			err = publisher.WriteAudio(&audioFrame)
-		case box.MP4_CODEC_G711U:
-			var audioFrame rtmp.RTMPAudio
-			audioFrame.Timestamp = uint32(ts)
-			audioFrame.Append([]byte{0x82}, sample.Data)
-			err = publisher.WriteAudio(&audioFrame)
-		}
-		return err
+	demuxerRange := &DemuxerRange{
+		Logger:  p.Logger.With("demuxer", "mp4"),
+		Streams: p.Streams,
 	}
 
 	for loop := 0; loop < p.Loop; loop++ {
@@ -186,7 +66,56 @@ func (p *RecordReader) Run() (err error) {
 		} else {
 			demuxerRange.EndTime = time.Now()
 		}
-		if err = demuxerRange.Demux(p.Context); err != nil {
+		if err = demuxerRange.Demux(p.Context, func(a *Audio) error {
+			if !publisher.HasAudioTrack() {
+				publisher.SetCodecCtx(demuxerRange.AudioTrack.ICodecCtx, a)
+			}
+			if publisher.Paused != nil {
+				publisher.Paused.Await()
+			}
+
+			// 检查是否需要跳转
+			if needSeek, seekErr := p.CheckSeek(); seekErr != nil {
+				return seekErr
+			} else if needSeek {
+				return pkg.ErrSkip
+			}
+
+			// 简化的时间戳处理
+			if int64(a.Timestamp)+tsOffset < 0 {
+				ts = 0
+			} else {
+				ts = int64(a.Timestamp) + tsOffset
+			}
+			a.Timestamp = uint32(ts)
+			return publisher.WriteAudio(a)
+		}, func(v *Video) error {
+			if !publisher.HasVideoTrack() {
+				publisher.SetCodecCtx(demuxerRange.VideoTrack.ICodecCtx, v)
+			}
+			if publisher.Paused != nil {
+				publisher.Paused.Await()
+			}
+
+			// 检查是否需要跳转
+			if needSeek, seekErr := p.CheckSeek(); seekErr != nil {
+				return seekErr
+			} else if needSeek {
+				return pkg.ErrSkip
+			}
+
+			// 简化的时间戳处理
+			if int64(v.Timestamp)+tsOffset < 0 {
+				ts = 0
+			} else {
+				ts = int64(v.Timestamp) + tsOffset
+			}
+
+			// 更新实时时间
+			realTime = time.Now() // 这里可以根据需要调整为更精确的时间计算
+			v.Timestamp = uint32(ts)
+			return publisher.WriteVideo(v)
+		}); err != nil {
 			if err == pkg.ErrSkip {
 				loop--
 				continue

plugin/mp4/pkg/record.go

@@ -6,15 +6,14 @@ import (
 	"os"
 	"path/filepath"
 	"time"
+	"bytes"
 
-	"gorm.io/gorm"
 	m7s "m7s.live/v5"
 	"m7s.live/v5/pkg"
 	"m7s.live/v5/pkg/codec"
 	"m7s.live/v5/pkg/config"
 	"m7s.live/v5/pkg/task"
 	"m7s.live/v5/plugin/mp4/pkg/box"
-	rtmp "m7s.live/v5/plugin/rtmp/pkg"
 )
 
 type WriteTrailerQueueTask struct {
@@ -107,39 +106,6 @@ func (t *writeTrailerTask) Run() (err error) {
 	return
 }
 
-type eventRecordCheck struct {
-	task.Task
-	DB         *gorm.DB
-	streamPath string
-}
-
-func (t *eventRecordCheck) Run() (err error) {
-	var eventRecordStreams []m7s.RecordStream
-	queryRecord := m7s.RecordStream{
-		EventLevel: m7s.EventLevelHigh,
-		Mode:       m7s.RecordModeEvent,
-		Type:       "mp4",
-		StreamPath: t.streamPath,
-	}
-	t.DB.Where(&queryRecord).Find(&eventRecordStreams) //搜索事件录像，且为重要事件（无法自动删除）
-	if len(eventRecordStreams) > 0 {
-		for _, recordStream := range eventRecordStreams {
-			var unimportantEventRecordStreams []m7s.RecordStream
-			queryRecord.EventLevel = m7s.EventLevelLow
-			queryRecord.Mode = m7s.RecordModeAuto
-			query := `start_time <= ? and end_time >= ?`
-			t.DB.Where(&queryRecord).Where(query, recordStream.EndTime, recordStream.StartTime).Find(&unimportantEventRecordStreams)
-			if len(unimportantEventRecordStreams) > 0 {
-				for _, unimportantEventRecordStream := range unimportantEventRecordStreams {
-					unimportantEventRecordStream.EventLevel = m7s.EventLevelHigh
-					t.DB.Save(&unimportantEventRecordStream)
-				}
-			}
-		}
-	}
-	return
-}
-
 func init() {
 	m7s.Servers.AddTask(&writeTrailerQueueTask)
 }
@@ -150,20 +116,12 @@ func NewRecorder(conf config.Record) m7s.IRecorder {
 
 type Recorder struct {
 	m7s.DefaultRecorder
-	muxer  *Muxer
-	file   *os.File
-	stream m7s.RecordStream
+	muxer *Muxer
+	file  *os.File
 }
 
 func (r *Recorder) writeTailer(end time.Time) {
-	r.stream.EndTime = end
-	if r.RecordJob.Plugin.DB != nil {
-		r.RecordJob.Plugin.DB.Save(&r.stream)
-		writeTrailerQueueTask.AddTask(&eventRecordCheck{
-			DB:         r.RecordJob.Plugin.DB,
-			streamPath: r.stream.StreamPath,
-		})
-	}
+	r.WriteTail(end, &writeTrailerQueueTask)
 	writeTrailerQueueTask.AddTask(&writeTrailerTask{
 		muxer: r.muxer,
 		file:  r.file,
@@ -178,46 +136,23 @@ var CustomFileName = func(job *m7s.RecordJob) string {
 }
 
 func (r *Recorder) createStream(start time.Time) (err error) {
-	recordJob := &r.RecordJob
-	sub := recordJob.Subscriber
-	r.stream = m7s.RecordStream{
-		StartTime:      start,
-		StreamPath:     sub.StreamPath,
-		FilePath:       CustomFileName(&r.RecordJob),
-		EventId:        recordJob.EventId,
-		EventDesc:      recordJob.EventDesc,
-		EventName:      recordJob.EventName,
-		EventLevel:     recordJob.EventLevel,
-		BeforeDuration: recordJob.BeforeDuration,
-		AfterDuration:  recordJob.AfterDuration,
-		Mode:           recordJob.Mode,
-		Type:           "mp4",
+	if r.RecordJob.RecConf.Type == "" {
+		r.RecordJob.RecConf.Type = "mp4"
 	}
-	dir := filepath.Dir(r.stream.FilePath)
-	if err = os.MkdirAll(dir, 0755); err != nil {
-		return
-	}
-	r.file, err = os.Create(r.stream.FilePath)
+	err = r.CreateStream(start, CustomFileName)
 	if err != nil {
 		return
 	}
-	if recordJob.RecConf.Type == "fmp4" {
-		r.stream.Type = "fmp4"
-		r.muxer = NewMuxerWithStreamPath(FLAG_FRAGMENT, r.stream.StreamPath)
+	r.file, err = os.Create(r.Event.FilePath)
+	if err != nil {
+		return
+	}
+	if r.Event.Type == "fmp4" {
+		r.muxer = NewMuxerWithStreamPath(FLAG_FRAGMENT, r.Event.StreamPath)
 	} else {
-		r.muxer = NewMuxerWithStreamPath(0, r.stream.StreamPath)
+		r.muxer = NewMuxerWithStreamPath(0, r.Event.StreamPath)
 	}
-	r.muxer.WriteInitSegment(r.file)
-	if sub.Publisher.HasAudioTrack() {
-		r.stream.AudioCodec = sub.Publisher.AudioTrack.ICodecCtx.String()
-	}
-	if sub.Publisher.HasVideoTrack() {
-		r.stream.VideoCodec = sub.Publisher.VideoTrack.ICodecCtx.String()
-	}
-	if recordJob.Plugin.DB != nil {
-		recordJob.Plugin.DB.Save(&r.stream)
-	}
-	return
+	return r.muxer.WriteInitSegment(r.file)
 }
 
 func (r *Recorder) Dispose() {
@@ -230,36 +165,24 @@ func (r *Recorder) Run() (err error) {
 	recordJob := &r.RecordJob
 	sub := recordJob.Subscriber
 	var audioTrack, videoTrack *Track
-	startTime := time.Now()
-	if recordJob.BeforeDuration > 0 {
-		startTime = startTime.Add(-recordJob.BeforeDuration)
-	}
-	err = r.createStream(startTime)
-	if err != nil {
-		return
-	}
 	var at, vt *pkg.AVTrack
-
 	checkEventRecordStop := func(absTime uint32) (err error) {
-		if duration := int64(absTime); time.Duration(duration)*time.Millisecond >= recordJob.AfterDuration+recordJob.BeforeDuration {
+		if absTime >= recordJob.Event.AfterDuration+recordJob.Event.BeforeDuration {
 			r.RecordJob.Stop(task.ErrStopByUser)
 		}
 		return
 	}
 
-	checkFragment := func(absTime uint32) (err error) {
-		if duration := int64(absTime); time.Duration(duration)*time.Millisecond >= recordJob.RecConf.Fragment {
-			now := time.Now()
-			r.writeTailer(now)
-			err = r.createStream(now)
+	checkFragment := func(reader *pkg.AVRingReader) (err error) {
+		if duration := int64(reader.AbsTime); time.Duration(duration)*time.Millisecond >= recordJob.RecConf.Fragment {
+			r.writeTailer(reader.Value.WriteTime)
+			err = r.createStream(reader.Value.WriteTime)
 			if err != nil {
 				return
 			}
 			at, vt = nil, nil
 			if vr := sub.VideoReader; vr != nil {
 				vr.ResetAbsTime()
-				//seq := vt.SequenceFrame.(*rtmp.RTMPVideo)
-				//offset = int64(seq.Size + 15)
 			}
 			if ar := sub.AudioReader; ar != nil {
 				ar.ResetAbsTime()
@@ -268,16 +191,23 @@ func (r *Recorder) Run() (err error) {
 		return
 	}
 
-	return m7s.PlayBlock(sub, func(audio *pkg.RawAudio) error {
+	return m7s.PlayBlock(sub, func(audio *Audio) error {
+		if r.Event.StartTime.IsZero() {
+			err = r.createStream(sub.AudioReader.Value.WriteTime)
+			if err != nil {
+				return err
+			}
+		}
+		r.Event.Duration = sub.AudioReader.AbsTime
 		if sub.VideoReader == nil {
-			if recordJob.AfterDuration != 0 {
+			if recordJob.Event != nil {
 				err := checkEventRecordStop(sub.VideoReader.AbsTime)
 				if err != nil {
 					return err
 				}
 			}
 			if recordJob.RecConf.Fragment != 0 {
-				err := checkFragment(sub.AudioReader.AbsTime)
+				err := checkFragment(sub.AudioReader)
 				if err != nil {
 					return err
 				}
@@ -307,92 +237,72 @@ func (r *Recorder) Run() (err error) {
 				track.ChannelCount = uint8(ctx.Channels)
 			}
 		}
-		dts := sub.AudioReader.AbsTime
-		return r.muxer.WriteSample(r.file, audioTrack, box.Sample{
-			Data:      audio.ToBytes(),
-			Timestamp: uint32(dts),
-		})
-	}, func(video *rtmp.RTMPVideo) error {
+		sample := audio.Sample
+		sample.Timestamp = uint32(sub.AudioReader.AbsTime)
+		return r.muxer.WriteSample(r.file, audioTrack, sample)
+	}, func(video *Video) error {
+		if r.Event.StartTime.IsZero() {
+			err = r.createStream(sub.VideoReader.Value.WriteTime)
+			if err != nil {
+				return err
+			}
+		}
+		r.Event.Duration = sub.VideoReader.AbsTime
 		if sub.VideoReader.Value.IDR {
-			if recordJob.AfterDuration != 0 {
+			if recordJob.Event != nil {
 				err := checkEventRecordStop(sub.VideoReader.AbsTime)
 				if err != nil {
 					return err
 				}
 			}
 			if recordJob.RecConf.Fragment != 0 {
-				err := checkFragment(sub.VideoReader.AbsTime)
+				err := checkFragment(sub.VideoReader)
 				if err != nil {
 					return err
 				}
 			}
 		}
-		offset := 5
-		bytes := video.ToBytes()
+
 		if vt == nil {
 			vt = sub.VideoReader.Track
+			ctx := vt.ICodecCtx.(pkg.IVideoCodecCtx)
+			width, height := uint32(ctx.Width()), uint32(ctx.Height())
 			switch ctx := vt.ICodecCtx.GetBase().(type) {
 			case *codec.H264Ctx:
 				track := r.muxer.AddTrack(box.MP4_CODEC_H264)
 				videoTrack = track
 				track.ExtraData = ctx.Record
-				track.Width = uint32(ctx.Width())
-				track.Height = uint32(ctx.Height())
+				track.Width = width
+				track.Height = height
 			case *codec.H265Ctx:
 				track := r.muxer.AddTrack(box.MP4_CODEC_H265)
 				videoTrack = track
 				track.ExtraData = ctx.Record
-				track.Width = uint32(ctx.Width())
-				track.Height = uint32(ctx.Height())
+				track.Width = width
+				track.Height = height
 			}
 		}
-		switch ctx := vt.ICodecCtx.(type) {
-		case *codec.H264Ctx:
-			if bytes[1] == 0 {
-				// Check if video resolution has changed
-				if uint32(ctx.Width()) != videoTrack.Width || uint32(ctx.Height()) != videoTrack.Height {
-					r.Info("Video resolution changed, restarting recording",
-						"old", fmt.Sprintf("%dx%d", videoTrack.Width, videoTrack.Height),
-						"new", fmt.Sprintf("%dx%d", ctx.Width(), ctx.Height()))
-					now := time.Now()
-					r.writeTailer(now)
-					err = r.createStream(now)
-					if err != nil {
-						return nil
-					}
-					at, vt = nil, nil
-					if vr := sub.VideoReader; vr != nil {
-						vr.ResetAbsTime()
-						//seq := vt.SequenceFrame.(*rtmp.RTMPVideo)
-						//offset = int64(seq.Size + 15)
-					}
-					if ar := sub.AudioReader; ar != nil {
-						ar.ResetAbsTime()
-					}
-				}
+		ctx := vt.ICodecCtx.(pkg.IVideoCodecCtx)
+		width, height := uint32(ctx.Width()), uint32(ctx.Height())
+		if !bytes.Equal(ctx.GetRecord(), videoTrack.ExtraData) {
+			r.Info("avcc changed, restarting recording",
+				"old", fmt.Sprintf("%dx%d", videoTrack.Width, videoTrack.Height),
+				"new", fmt.Sprintf("%dx%d", width, height))
+			r.writeTailer(sub.VideoReader.Value.WriteTime)
+			err = r.createStream(sub.VideoReader.Value.WriteTime)
+			if err != nil {
 				return nil
 			}
-		case *rtmp.H265Ctx:
-			if ctx.Enhanced {
-				switch t := bytes[0] & 0b1111; t {
-				case rtmp.PacketTypeCodedFrames:
-					offset += 3
-				case rtmp.PacketTypeSequenceStart:
-					return nil
-				case rtmp.PacketTypeCodedFramesX:
-				default:
-					r.Warn("unknown h265 packet type", "type", t)
-					return nil
-				}
-			} else if bytes[1] == 0 {
-				return nil
+			at, vt = nil, nil
+			if vr := sub.VideoReader; vr != nil {
+				vr.ResetAbsTime()
+			}
+			if ar := sub.AudioReader; ar != nil {
+				ar.ResetAbsTime()
 			}
 		}
-		return r.muxer.WriteSample(r.file, videoTrack, box.Sample{
-			KeyFrame:  sub.VideoReader.Value.IDR,
-			Data:      bytes[offset:],
-			Timestamp: uint32(sub.VideoReader.AbsTime),
-			CTS:       video.CTS,
-		})
+		sample := video.Sample
+		sample.Timestamp = uint32(sub.VideoReader.AbsTime)
+		return r.muxer.WriteSample(r.file, videoTrack, sample)
 	})
 }

plugin/mp4/pkg/track.go

@@ -87,19 +87,17 @@ func (track *Track) makeElstBox() *EditListBox {
 
 }
 
-func (track *Track) Seek(dts uint64) int {
+func (track *Track) Seek(dts uint64) (idx int) {
+	idx = -1
 	for i, sample := range track.Samplelist {
-		if sample.Timestamp*1000/uint32(track.Timescale) < uint32(dts) {
-			continue
-		} else if track.Cid.IsVideo() {
-			if sample.KeyFrame {
-				return i
-			}
-		} else {
-			return i
+		if track.Cid.IsVideo() && sample.KeyFrame {
+			idx = i
+		}
+		if sample.Timestamp*1000/uint32(track.Timescale) > uint32(dts) {
+			break
 		}
 	}
-	return -1
+	return
 }
 
 func (track *Track) makeEdtsBox() *ContainerBox {

plugin/mp4/pkg/video.go

@@ -0,0 +1,170 @@
+package mp4
+
+import (
+	"fmt"
+	"io"
+	"slices"
+	"time"
+
+	"m7s.live/v5/pkg"
+	"m7s.live/v5/pkg/codec"
+	"m7s.live/v5/pkg/util"
+	"m7s.live/v5/plugin/mp4/pkg/box"
+)
+
+var _ pkg.IAVFrame = (*Video)(nil)
+
+type Video struct {
+	box.Sample
+	allocator *util.ScalableMemoryAllocator
+}
+
+// GetAllocator implements pkg.IAVFrame.
+func (v *Video) GetAllocator() *util.ScalableMemoryAllocator {
+	return v.allocator
+}
+
+// SetAllocator implements pkg.IAVFrame.
+func (v *Video) SetAllocator(allocator *util.ScalableMemoryAllocator) {
+	v.allocator = allocator
+}
+
+// Parse implements pkg.IAVFrame.
+func (v *Video) Parse(t *pkg.AVTrack) error {
+	t.Value.IDR = v.KeyFrame
+	return nil
+}
+
+// ConvertCtx implements pkg.IAVFrame.
+func (v *Video) ConvertCtx(ctx codec.ICodecCtx) (codec.ICodecCtx, pkg.IAVFrame, error) {
+	// 返回基础编解码器上下文，不进行转换
+	return ctx.GetBase(), nil, nil
+}
+
+// Demux implements pkg.IAVFrame.
+func (v *Video) Demux(codecCtx codec.ICodecCtx) (any, error) {
+	if len(v.Data) == 0 {
+		return nil, fmt.Errorf("no video data to demux")
+	}
+
+	// 创建内存读取器
+	var mem util.Memory
+	mem.AppendOne(v.Data)
+	reader := mem.NewReader()
+
+	var nalus pkg.Nalus
+
+	// 根据编解码器类型进行解复用
+	switch ctx := codecCtx.(type) {
+	case *codec.H264Ctx:
+		// 对于 H.264，解析 AVCC 格式的 NAL 单元
+		if err := nalus.ParseAVCC(reader, int(ctx.RecordInfo.LengthSizeMinusOne)+1); err != nil {
+			return nil, fmt.Errorf("failed to parse H.264 AVCC: %w", err)
+		}
+	case *codec.H265Ctx:
+		// 对于 H.265，解析 AVCC 格式的 NAL 单元
+		if err := nalus.ParseAVCC(reader, int(ctx.RecordInfo.LengthSizeMinusOne)+1); err != nil {
+			return nil, fmt.Errorf("failed to parse H.265 AVCC: %w", err)
+		}
+	default:
+		// 对于其他格式，尝试默认的 AVCC 解析（4字节长度前缀）
+		if err := nalus.ParseAVCC(reader, 4); err != nil {
+			return nil, fmt.Errorf("failed to parse AVCC with default settings: %w", err)
+		}
+	}
+
+	return nalus, nil
+}
+
+// Mux implements pkg.IAVFrame.
+func (v *Video) Mux(codecCtx codec.ICodecCtx, frame *pkg.AVFrame) {
+	// 从 AVFrame 复制数据到 MP4 Sample
+	v.KeyFrame = frame.IDR
+	v.Timestamp = uint32(frame.Timestamp.Milliseconds())
+	v.CTS = uint32(frame.CTS.Milliseconds())
+
+	// 处理原始数据
+	if frame.Raw != nil {
+		switch rawData := frame.Raw.(type) {
+		case pkg.Nalus:
+			// 将 Nalus 转换为 AVCC 格式的字节数据
+			var buffer util.Buffer
+
+			// 根据编解码器类型确定 NALU 长度字段的大小
+			var naluSizeLen int = 4 // 默认使用 4 字节
+			switch ctx := codecCtx.(type) {
+			case *codec.H264Ctx:
+				naluSizeLen = int(ctx.RecordInfo.LengthSizeMinusOne) + 1
+			case *codec.H265Ctx:
+				naluSizeLen = int(ctx.RecordInfo.LengthSizeMinusOne) + 1
+			}
+
+			// 为每个 NALU 添加长度前缀
+			for _, nalu := range rawData {
+				util.PutBE(buffer.Malloc(naluSizeLen), nalu.Size) // 写入 NALU 长度
+				var buffers = slices.Clone(nalu.Buffers)          // 克隆 NALU 的缓冲区
+				buffers.WriteTo(&buffer)                          // 直接写入 NALU 数据
+			}
+			v.Data = buffer
+			v.Size = len(v.Data)
+
+		case []byte:
+			// 直接复制字节数据
+			v.Data = rawData
+			v.Size = len(v.Data)
+
+		default:
+			// 对于其他类型，尝试转换为字节
+			v.Data = nil
+			v.Size = 0
+		}
+	} else {
+		v.Data = nil
+		v.Size = 0
+	}
+}
+
+// GetTimestamp implements pkg.IAVFrame.
+func (v *Video) GetTimestamp() time.Duration {
+	return time.Duration(v.Timestamp) * time.Millisecond
+}
+
+// GetCTS implements pkg.IAVFrame.
+func (v *Video) GetCTS() time.Duration {
+	return time.Duration(v.CTS) * time.Millisecond
+}
+
+// GetSize implements pkg.IAVFrame.
+func (v *Video) GetSize() int {
+	return v.Size
+}
+
+// Recycle implements pkg.IAVFrame.
+func (v *Video) Recycle() {
+	// 回收资源
+	if v.allocator != nil && v.Data != nil {
+		// 如果数据是通过分配器分配的，这里可以进行回收
+		// 由于我们使用的是复制的数据，这里暂时不需要特殊处理
+	}
+	v.Data = nil
+	v.Size = 0
+	v.KeyFrame = false
+	v.Timestamp = 0
+	v.CTS = 0
+	v.Offset = 0
+	v.Duration = 0
+}
+
+// String implements pkg.IAVFrame.
+func (v *Video) String() string {
+	return fmt.Sprintf("MP4Video[ts:%d, cts:%d, size:%d, keyframe:%t]",
+		v.Timestamp, v.CTS, v.Size, v.KeyFrame)
+}
+
+// Dump implements pkg.IAVFrame.
+func (v *Video) Dump(t byte, w io.Writer) {
+	// 输出数据到 writer
+	if v.Data != nil {
+		w.Write(v.Data)
+	}
+}

plugin/mp4/recovery.go

@@ -185,8 +185,6 @@ func (t *RecordRecoveryTask) recoverRecordFromFile(filePath string) error {
 		FilePath:   filePath,
 		StreamPath: streamPath,
 		Type:       "mp4",
-		Mode:       m7s.RecordModeAuto, // 默认为自动录制模式
-		EventLevel: m7s.EventLevelLow,  // 默认为低级别事件
 	}
 
 	// 设置开始和结束时间
@@ -220,8 +218,8 @@ func extractStreamPathFromMP4(demuxer *mp4.Demuxer) string {
 	moov := demuxer.GetMoovBox()
 	if moov != nil && moov.UDTA != nil {
 		for _, entry := range moov.UDTA.Entries {
-			if streamPathBox, ok := entry.(*box.StreamPathBox); ok {
-				return streamPathBox.StreamPath
+			if entry.Type() == box.TypeALB {
+				return entry.(*box.TextDataBox).Text
 			}
 		}
 	}

plugin/mp4/util.go

@@ -0,0 +1,99 @@
+package plugin_mp4
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"os/exec"
+
+	"github.com/deepch/vdk/codec/h264parser"
+	"github.com/deepch/vdk/codec/h265parser"
+	"m7s.live/v5/pkg"
+	"m7s.live/v5/pkg/codec"
+	mp4 "m7s.live/v5/plugin/mp4/pkg"
+	"m7s.live/v5/plugin/mp4/pkg/box"
+)
+
+// ProcessWithFFmpeg 使用 FFmpeg 处理视频帧并生成截图
+func ProcessWithFFmpeg(samples []box.Sample, index int, videoTrack *mp4.Track, output io.Writer) error {
+	// 创建ffmpeg命令，直接输出JPEG格式
+	cmd := exec.Command("ffmpeg",
+		"-hide_banner",
+		"-i", "pipe:0",
+		"-vf", fmt.Sprintf("select=eq(n\\,%d)", index),
+		"-vframes", "1",
+		"-f", "mjpeg",
+		"pipe:1")
+
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		return err
+	}
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return err
+	}
+
+	stderr, err := cmd.StderrPipe()
+	if err != nil {
+		return err
+	}
+	go func() {
+		errOutput, _ := io.ReadAll(stderr)
+		log.Printf("FFmpeg stderr: %s", errOutput)
+	}()
+
+	if err = cmd.Start(); err != nil {
+		log.Printf("cmd.Start失败: %v", err)
+		return err
+	}
+
+	go func() {
+		defer stdin.Close()
+		convert := pkg.NewAVFrameConvert[*pkg.AnnexB](nil, nil)
+		switch videoTrack.Cid {
+		case box.MP4_CODEC_H264:
+			var h264Ctx codec.H264Ctx
+			h264Ctx.CodecData, err = h264parser.NewCodecDataFromAVCDecoderConfRecord(videoTrack.ExtraData)
+			if err != nil {
+				log.Printf("解析H264失败: %v", err)
+				return
+			}
+			convert.FromTrack.ICodecCtx = &h264Ctx
+		case box.MP4_CODEC_H265:
+			var h265Ctx codec.H265Ctx
+			h265Ctx.CodecData, err = h265parser.NewCodecDataFromAVCDecoderConfRecord(videoTrack.ExtraData)
+			if err != nil {
+				log.Printf("解析H265失败: %v", err)
+				return
+			}
+			convert.FromTrack.ICodecCtx = &h265Ctx
+		default:
+			log.Printf("不支持的编解码器: %v", videoTrack.Cid)
+			return
+		}
+		for _, sample := range samples {
+			annexb, err := convert.Convert(&mp4.Video{
+				Sample: sample,
+			})
+			if err != nil {
+				log.Printf("转换失败: %v", err)
+				continue
+			}
+			annexb.WriteTo(stdin)
+		}
+	}()
+
+	// 从ffmpeg的stdout读取JPEG数据并写入到输出
+	if _, err = io.Copy(output, stdout); err != nil {
+		log.Printf("读取失败: %v", err)
+		return err
+	}
+	if err = cmd.Wait(); err != nil {
+		log.Printf("cmd.Wait失败: %v", err)
+		return err
+	}
+
+	log.Printf("ffmpeg JPEG输出成功")
+	return nil
+}

plugin/rtmp/pkg/handshake.go

@@ -79,10 +79,10 @@ func (nc *NetConnection) Handshake(checkC2 bool) (err error) {
 	if len(C1) != C1S1_SIZE {
 		return errors.New("C1 Error")
 	}
-	var ts int
-	util.GetBE(C1[4:8], &ts)
+	var zero int
+	util.GetBE(C1[4:8], &zero)
 
-	if ts == 0 {
+	if zero == 0 {
 		return nc.simple_handshake(C1, checkC2)
 	}
 
@@ -92,12 +92,26 @@ func (nc *NetConnection) Handshake(checkC2 bool) (err error) {
 func (nc *NetConnection) ClientHandshake() (err error) {
 	C0C1 := nc.mediaDataPool.NextN(C1S1_SIZE + 1)
 	defer nc.mediaDataPool.Recycle()
+
+	// 构造 C0
 	C0C1[0] = RTMP_HANDSHAKE_VERSION
+
+	// 构造 C1 使用简单握手格式
+	C1 := C0C1[1:]
+	// Time (4 bytes): 当前时间戳
+	util.PutBE(C1[0:4], time.Now().Unix()&0xFFFFFFFF)
+	// Zero (4 bytes): 必须为 0，确保使用简单握手
+	util.PutBE(C1[4:8], 0)
+	// Random data (1528 bytes): 填充随机数据
+	for i := 8; i < C1S1_SIZE; i++ {
+		C1[i] = byte(rand.Int() % 256)
+	}
+
 	if _, err = nc.Write(C0C1); err == nil {
 		// read S0 S1
 		if _, err = io.ReadFull(nc.Conn, C0C1); err == nil {
 			if C0C1[0] != RTMP_HANDSHAKE_VERSION {
-				err = errors.New("S1 C1 Error")
+				err = errors.New("S0 Error")
 				// C2
 			} else if _, err = nc.Write(C0C1[1:]); err == nil {
 				_, err = io.ReadFull(nc.Conn, C0C1[1:]) // S2
@@ -222,13 +236,7 @@ func clientScheme(C1 []byte, schem int) (scheme int, challenge []byte, digest []
 		return 0, nil, nil, false, err
 	}
 
-	// ok
-	if bytes.Compare(digest, tmp_Hash) == 0 {
-		ok = true
-	} else {
-		ok = false
-	}
-
+	ok = bytes.Equal(digest, tmp_Hash)
 	// challenge scheme
 	challenge = C1[key_offset : key_offset+C1S1_KEY_DATA_SIZE]
 	scheme = schem

plugin/snap/api.go

@@ -46,7 +46,7 @@ func parseRGBA(rgba string) (color.RGBA, error) {
 func (p *SnapPlugin) snap(publisher *m7s.Publisher, watermarkConfig *snap_pkg.WatermarkConfig) (*bytes.Buffer, error) {
 
 	// 获取视频帧
-	annexb, _, err := snap_pkg.GetVideoFrame(publisher, p.Server)
+	annexb, err := snap_pkg.GetVideoFrame(publisher, p.Server)
 	if err != nil {
 		return nil, err
 	}

plugin/snap/pkg/transform.go

@@ -183,7 +183,7 @@ func (t *TimeSnapTask) GetTickInterval() time.Duration {
 // Tick 执行定时截图操作
 func (t *TimeSnapTask) Tick(any) {
 	// 获取视频帧
-	annexb, _, err := GetVideoFrame(t.job.OriginPublisher, t.job.Plugin.Server)
+	annexb, err := GetVideoFrame(t.job.OriginPublisher, t.job.Plugin.Server)
 	if err != nil {
 		t.Error("get video frame failed", "error", err.Error())
 		return

plugin/snap/pkg/util.go

@@ -10,45 +10,34 @@ import (
 )
 
 // GetVideoFrame 获取视频帧数据
-func GetVideoFrame(publisher *m7s.Publisher, server *m7s.Server) ([]*pkg.AnnexB, *pkg.AVTrack, error) {
+func GetVideoFrame(publisher *m7s.Publisher, server *m7s.Server) ([]*pkg.AnnexB, error) {
 	if publisher.VideoTrack.AVTrack == nil {
-		return nil, nil, pkg.ErrNotFound
+		return nil, pkg.ErrNotFound
 	}
 
 	// 等待视频就绪
 	if err := publisher.VideoTrack.WaitReady(); err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
 	// 创建读取器并等待 I 帧
 	reader := pkg.NewAVRingReader(publisher.VideoTrack.AVTrack, "snapshot")
 	if err := reader.StartRead(publisher.VideoTrack.GetIDR()); err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 	defer reader.StopRead()
-	var track pkg.AVTrack
-	var annexb pkg.AnnexB
-	var err error
-	track.ICodecCtx, track.SequenceFrame, err = annexb.ConvertCtx(publisher.VideoTrack.ICodecCtx)
-	if err != nil {
-		return nil, nil, err
-	}
-	if track.ICodecCtx == nil {
-		return nil, nil, pkg.ErrUnsupportCodec
-	}
+	var converter = pkg.NewAVFrameConvert[*pkg.AnnexB](publisher.VideoTrack.AVTrack, nil)
+
 	var annexbList []*pkg.AnnexB
 
 	for lastFrameSequence := publisher.VideoTrack.AVTrack.LastValue.Sequence; reader.Value.Sequence <= lastFrameSequence; reader.ReadNext() {
-		if reader.Value.Raw == nil {
-			if err := reader.Value.Demux(publisher.VideoTrack.ICodecCtx); err != nil {
-				return nil, nil, err
-			}
+		annexb, err := converter.ConvertFromAVFrame(&reader.Value)
+		if err != nil {
+			return nil, err
 		}
-		var annexb pkg.AnnexB
-		annexb.Mux(track.ICodecCtx, &reader.Value)
-		annexbList = append(annexbList, &annexb)
+		annexbList = append(annexbList, annexb)
 	}
-	return annexbList, &track, nil
+	return annexbList, nil
 }
 
 // ProcessWithFFmpeg 使用 FFmpeg 处理视频帧并生成截图

plugin/webrtc/api.go

@@ -40,7 +40,11 @@ func (conf *WebRTCPlugin) servePush(w http.ResponseWriter, r *http.Request) {
 	}
 	conn.SDP = string(bytes)
 	conn.Logger = conf.Logger
-	if conn.PeerConnection, err = conf.api.NewPeerConnection(Configuration{
+
+	if conn.PeerConnection, err = conf.CreatePC(SessionDescription{
+		Type: SDPTypeOffer,
+		SDP:  conn.SDP,
+	}, Configuration{
 		ICEServers: conf.ICEServers,
 	}); err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -56,10 +60,7 @@ func (conf *WebRTCPlugin) servePush(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
-	if err := conn.SetRemoteDescription(SessionDescription{Type: SDPTypeOffer, SDP: conn.SDP}); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
+
 	if answer, err := conn.GetAnswer(); err == nil {
 		w.WriteHeader(http.StatusCreated)
 		fmt.Fprint(w, answer.SDP)
@@ -89,9 +90,15 @@ func (conf *WebRTCPlugin) servePlay(w http.ResponseWriter, r *http.Request) {
 	if strings.Contains(strings.ToLower(conn.SDP), "h265") {
 		conn.SupportsH265 = true
 	}
-	if conn.PeerConnection, err = conf.api.NewPeerConnection(Configuration{
+
+	conn.PeerConnection, err = conf.CreatePC(SessionDescription{
+		Type: SDPTypeOffer,
+		SDP:  conn.SDP,
+	}, Configuration{
 		ICEServers: conf.ICEServers,
-	}); err != nil {
+	})
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 	if rawQuery != "" {
@@ -106,10 +113,7 @@ func (conf *WebRTCPlugin) servePlay(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
-	if err = conn.SetRemoteDescription(SessionDescription{Type: SDPTypeOffer, SDP: conn.SDP}); err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
+
 	if sdp, err := conn.GetAnswer(); err == nil {
 		w.Write([]byte(sdp.SDP))
 	} else {

plugin/webrtc/batchv2.go

@@ -2,6 +2,7 @@ package plugin_webrtc
 
 import (
 	"encoding/json"
+	"errors"
 	"net"
 	"net/http"
 	"strings"
@@ -35,17 +36,7 @@ func (conf *WebRTCPlugin) BatchV2(w http.ResponseWriter, r *http.Request) {
 		conn:   wsConn,
 		config: conf,
 	}
-	// 创建PeerConnection并设置高级配置
-	if wsHandler.PeerConnection, err = conf.api.NewPeerConnection(Configuration{
-		// 本地测试不需要配置 ICE 服务器
-		ICETransportPolicy:   ICETransportPolicyAll,
-		BundlePolicy:         BundlePolicyMaxBundle,
-		RTCPMuxPolicy:        RTCPMuxPolicyRequire,
-		ICECandidatePoolSize: 1,
-	}); err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
+
 	// 添加任务
 	conf.AddTask(wsHandler).WaitStopped()
 }
@@ -89,15 +80,43 @@ func (wsh *WebSocketHandler) Go() (err error) {
 	if strings.Contains(strings.ToLower(wsh.SDP), "h265") {
 		wsh.SupportsH265 = true
 	}
-	// 设置远程描述
-	if err = wsh.SetRemoteDescription(SessionDescription{
+
+	if wsh.PeerConnection, err = wsh.config.CreatePC(SessionDescription{
 		Type: SDPTypeOffer,
 		SDP:  initialSignal.SDP,
+	}, Configuration{
+		// 本地测试不需要配置 ICE 服务器
+		ICETransportPolicy:   ICETransportPolicyAll,
+		BundlePolicy:         BundlePolicyMaxBundle,
+		RTCPMuxPolicy:        RTCPMuxPolicyRequire,
+		ICECandidatePoolSize: 1,
 	}); err != nil {
-		wsh.Error("Failed to set remote description", "error", err)
-		return err
+		return
 	}
 
+	wsh.OnICECandidate(func(ice *ICECandidate) {
+		if ice != nil {
+			wsh.Info(ice.ToJSON().Candidate)
+		}
+	})
+	// 监听ICE连接状态变化
+	wsh.OnICEConnectionStateChange(func(state ICEConnectionState) {
+		wsh.Debug("ICE connection state changed", "state", state.String())
+		if state == ICEConnectionStateFailed {
+			wsh.Error("ICE connection failed")
+		}
+	})
+
+	wsh.OnConnectionStateChange(func(state PeerConnectionState) {
+		wsh.Info("Connection State has changed:" + state.String())
+		switch state {
+		case PeerConnectionStateConnected:
+
+		case PeerConnectionStateDisconnected, PeerConnectionStateFailed, PeerConnectionStateClosed:
+			wsh.Stop(errors.New("connection state:" + state.String()))
+		}
+	})
+
 	// 创建并发送应答
 	if answer, err := wsh.GetAnswer(); err == nil {
 		wsh.sendAnswer(answer.SDP)
@@ -134,6 +153,8 @@ func (wsh *WebSocketHandler) Go() (err error) {
 			wsh.handleAnswer(signal)
 		case SignalTypeGetStreamList:
 			wsh.handleGetStreamList()
+		case SignalTypePing:
+			wsh.handlePing(signal)
 		default:
 			wsh.sendError("Unknown signal type: " + string(signal.Type))
 		}
@@ -142,7 +163,9 @@ func (wsh *WebSocketHandler) Go() (err error) {
 
 // Dispose 清理资源
 func (wsh *WebSocketHandler) Dispose() {
-	wsh.PeerConnection.Close()
+	if wsh.PeerConnection != nil {
+		wsh.PeerConnection.Close()
+	}
 	wsh.conn.Close()
 }
 
@@ -171,6 +194,20 @@ func (wsh *WebSocketHandler) sendError(message string) error {
 	})
 }
 
+func (wsh *WebSocketHandler) handlePing(signal Signal) {
+	// 处理ping信号，直接回复pong
+	if signal.Type == SignalTypePing {
+		wsh.Debug("Received ping, sending pong")
+		if err := wsh.sendJSON(Signal{
+			Type: SignalTypePong,
+		}); err != nil {
+			wsh.Error("Failed to send pong", "error", err)
+		}
+	} else {
+		wsh.sendError("Invalid signal type for ping: " + string(signal.Type))
+	}
+}
+
 // handlePublish 处理发布信号
 func (wsh *WebSocketHandler) handlePublish(signal Signal) {
 	if publisher, err := wsh.config.Publish(wsh, signal.StreamPath); err == nil {

plugin/webrtc/default.yaml

@@ -0,0 +1,5 @@
+mimetype:
+  - video/H264
+  - video/H265
+  - audio/PCMA
+  - audio/PCMU

plugin/webrtc/index.go

@@ -2,16 +2,17 @@ package plugin_webrtc
 
 import (
 	"embed"
-	_ "embed"
 	"fmt"
 	"io"
 	"net"
 	"net/http"
 	"regexp"
+	"strconv"
 	"strings"
 	"time"
 
 	"github.com/pion/logging"
+	"github.com/pion/sdp/v3"
 	"m7s.live/v5/pkg/config"
 
 	"github.com/pion/interceptor"
@@ -23,9 +24,15 @@ import (
 
 var (
 	//go:embed web
-	web       embed.FS
-	reg_level = regexp.MustCompile("profile-level-id=(4.+f)")
-	_         = m7s.InstallPlugin[WebRTCPlugin](NewPuller, NewPusher)
+	web embed.FS
+	//go:embed default.yaml
+	defaultYaml m7s.DefaultYaml
+	reg_level   = regexp.MustCompile("profile-level-id=(4.+f)")
+	_           = m7s.InstallPlugin[WebRTCPlugin](m7s.PluginMeta{
+		DefaultYaml: defaultYaml,
+		NewPuller:   NewPuller,
+		NewPusher:   NewPusher,
+	})
 )
 
 type WebRTCPlugin struct {
@@ -33,13 +40,9 @@ type WebRTCPlugin struct {
 	ICEServers []ICEServer   `desc:"ice服务器配置"`
 	Port       string        `default:"tcp:9000" desc:"监听端口"`
 	PLI        time.Duration `default:"2s" desc:"发送PLI请求间隔"`         // 视频流丢包后，发送PLI请求
-	EnableOpus bool          `default:"true" desc:"是否启用opus编码"`      // 是否启用opus编码
-	EnableVP9  bool          `default:"false" desc:"是否启用vp9编码"`      // 是否启用vp9编码
-	EnableAv1  bool          `default:"false" desc:"是否启用av1编码"`      // 是否启用av1编码
 	EnableDC   bool          `default:"true" desc:"是否启用DataChannel"` // 在不支持编码格式的情况下是否启用DataChannel传输
-	m          MediaEngine
+	MimeType   []string      `desc:"MimeType过滤列表，为空则不过滤"`            // MimeType过滤列表，支持的格式如：video/H264, audio/opus
 	s          SettingEngine
-	api        *API
 }
 
 func (p *WebRTCPlugin) RegisterHandler() map[string]http.HandlerFunc {
@@ -54,35 +57,237 @@ func (p *WebRTCPlugin) NewLogger(scope string) logging.LeveledLogger {
 	return &LoggerTransform{Logger: p.Logger.With("scope", scope)}
 }
 
-func (p *WebRTCPlugin) OnInit() (err error) {
-	if len(p.ICEServers) > 0 {
-		for i := range p.ICEServers {
-			b, _ := p.ICEServers[i].MarshalJSON()
-			p.ICEServers[i].UnmarshalJSON(b)
+// createMediaEngine 创建新的MediaEngine实例
+func (p *WebRTCPlugin) createMediaEngine(ssd *sdp.SessionDescription) *MediaEngine {
+	m := &MediaEngine{}
+
+	// 如果没有提供SDP，则使用传统方式注册编解码器
+	if ssd == nil {
+		p.registerLegacyCodecs(m)
+		return m
+	}
+
+	// 从SDP中解析MediaDescription并注册编解码器
+	p.registerCodecsFromSDP(m, ssd)
+
+	return m
+}
+
+// registerLegacyCodecs 注册传统方式的编解码器（向后兼容）
+func (p *WebRTCPlugin) registerLegacyCodecs(m *MediaEngine) {
+	// 注册基础编解码器
+	if defaultCodecs, err := GetDefaultCodecs(); err != nil {
+		p.Error("Failed to get default codecs", "error", err)
+	} else {
+		for _, codecWithType := range defaultCodecs {
+			// 检查MimeType过滤
+			if p.isMimeTypeAllowed(codecWithType.Codec.MimeType) {
+				if err := m.RegisterCodec(codecWithType.Codec, codecWithType.Type); err != nil {
+					p.Warn("Failed to register default codec", "error", err, "mimeType", codecWithType.Codec.MimeType)
+				} else {
+					p.Debug("Registered default codec", "mimeType", codecWithType.Codec.MimeType, "payloadType", codecWithType.Codec.PayloadType)
+				}
+			} else {
+				p.Debug("Default codec filtered", "mimeType", codecWithType.Codec.MimeType)
+			}
+		}
+	}
+}
+
+// registerCodecsFromSDP 从SDP的MediaDescription中注册编解码器
+func (p *WebRTCPlugin) registerCodecsFromSDP(m *MediaEngine, ssd *sdp.SessionDescription) {
+	for _, md := range ssd.MediaDescriptions {
+		// 跳过非音视频媒体类型
+		if md.MediaName.Media != "audio" && md.MediaName.Media != "video" {
+			continue
+		}
+
+		// 解析每个format（编解码器）
+		for _, format := range md.MediaName.Formats {
+			codec := p.parseCodecFromSDP(md, format)
+			if codec == nil {
+				continue
+			}
+
+			// 检查MimeType过滤
+			if !p.isMimeTypeAllowed(codec.MimeType) {
+				p.Debug("MimeType filtered", "mimeType", codec.MimeType)
+				continue
+			}
+
+			// 确定编解码器类型
+			var codecType RTPCodecType
+			if md.MediaName.Media == "audio" {
+				codecType = RTPCodecTypeAudio
+			} else {
+				codecType = RTPCodecTypeVideo
+			}
+
+			// 注册编解码器
+			if err := m.RegisterCodec(*codec, codecType); err != nil {
+				p.Warn("Failed to register codec from SDP", "error", err, "mimeType", codec.MimeType)
+			} else {
+				p.Debug("Registered codec from SDP", "mimeType", codec.MimeType, "payloadType", codec.PayloadType)
+			}
+		}
+	}
+}
+
+// parseCodecFromSDP 从SDP的MediaDescription中解析单个编解码器
+func (p *WebRTCPlugin) parseCodecFromSDP(md *sdp.MediaDescription, format string) *RTPCodecParameters {
+	var codecName string
+	var clockRate uint32
+	var channels uint16
+	var fmtpLine string
+
+	// 从rtpmap属性中解析编解码器名称、时钟频率和通道数
+	for _, attr := range md.Attributes {
+		if attr.Key == "rtpmap" && strings.HasPrefix(attr.Value, format+" ") {
+			// 格式：payloadType codecName/clockRate[/channels]
+			parts := strings.Split(attr.Value, " ")
+			if len(parts) >= 2 {
+				codecParts := strings.Split(parts[1], "/")
+				if len(codecParts) >= 2 {
+					codecName = strings.ToUpper(codecParts[0])
+					if rate, err := strconv.ParseUint(codecParts[1], 10, 32); err == nil {
+						clockRate = uint32(rate)
+					}
+					if len(codecParts) >= 3 {
+						if ch, err := strconv.ParseUint(codecParts[2], 10, 16); err == nil {
+							channels = uint16(ch)
+						}
+					}
+				}
+			}
+			break
 		}
 	}
 
-	p.s.LoggerFactory = p
-	RegisterCodecs(&p.m)
-	if p.EnableOpus {
-		p.m.RegisterCodec(RTPCodecParameters{
-			RTPCodecCapability: RTPCodecCapability{MimeTypeOpus, 48000, 2, "minptime=10;useinbandfec=1", nil},
-			PayloadType:        111,
-		}, RTPCodecTypeAudio)
+	// 从fmtp属性中解析格式参数
+	for _, attr := range md.Attributes {
+		if attr.Key == "fmtp" && strings.HasPrefix(attr.Value, format+" ") {
+			if spaceIdx := strings.Index(attr.Value, " "); spaceIdx >= 0 {
+				fmtpLine = attr.Value[spaceIdx+1:]
+			}
+			break
+		}
 	}
-	if p.EnableVP9 {
-		p.m.RegisterCodec(RTPCodecParameters{
-			RTPCodecCapability: RTPCodecCapability{MimeTypeVP9, 90000, 0, "", nil},
-			PayloadType:        100,
-		}, RTPCodecTypeVideo)
+
+	// 如果没有找到rtpmap，尝试静态payload类型
+	if codecName == "" {
+		codecName, clockRate, channels = p.getStaticPayloadInfo(format)
 	}
-	if p.EnableAv1 {
-		p.m.RegisterCodec(RTPCodecParameters{
-			RTPCodecCapability: RTPCodecCapability{MimeTypeAV1, 90000, 0, "profile=2;level-idx=8;tier=1", nil},
-			PayloadType:        45,
-		}, RTPCodecTypeVideo)
+
+	if codecName == "" {
+		return nil
 	}
+
+	// 构造MimeType
+	var mimeType string
+	if md.MediaName.Media == "audio" {
+		mimeType = "audio/" + codecName
+	} else {
+		mimeType = "video/" + codecName
+	}
+
+	// 解析PayloadType
+	payloadType, err := strconv.ParseUint(format, 10, 8)
+	if err != nil {
+		return nil
+	}
+
+	return &RTPCodecParameters{
+		RTPCodecCapability: RTPCodecCapability{
+			MimeType:     mimeType,
+			ClockRate:    clockRate,
+			Channels:     channels,
+			SDPFmtpLine:  fmtpLine,
+			RTCPFeedback: p.getDefaultRTCPFeedback(mimeType),
+		},
+		PayloadType: PayloadType(payloadType),
+	}
+}
+
+// getStaticPayloadInfo 获取静态payload类型的编解码器信息
+func (p *WebRTCPlugin) getStaticPayloadInfo(format string) (string, uint32, uint16) {
+	switch format {
+	case "0":
+		return "PCMU", 8000, 1
+	case "8":
+		return "PCMA", 8000, 1
+	case "96":
+		return "H264", 90000, 0
+	case "97":
+		return "H264", 90000, 0
+	case "98":
+		return "H264", 90000, 0
+	case "111":
+		return "OPUS", 48000, 2
+	default:
+		return "", 0, 0
+	}
+}
+
+// getDefaultRTCPFeedback 获取默认的RTCP反馈
+func (p *WebRTCPlugin) getDefaultRTCPFeedback(mimeType string) []RTCPFeedback {
+	if strings.HasPrefix(mimeType, "video/") {
+		return []RTCPFeedback{
+			{Type: "goog-remb", Parameter: ""},
+			{Type: "ccm", Parameter: "fir"},
+			{Type: "nack", Parameter: ""},
+			{Type: "nack", Parameter: "pli"},
+			{Type: "transport-cc", Parameter: ""},
+		}
+	}
+	return nil
+}
+
+// isMimeTypeAllowed 检查MimeType是否在允许列表中
+func (p *WebRTCPlugin) isMimeTypeAllowed(mimeType string) bool {
+	// 如果过滤列表为空，则允许所有类型
+	if len(p.MimeType) == 0 {
+		return true
+	}
+
+	// 检查精确匹配
+	for _, filter := range p.MimeType {
+		if strings.EqualFold(filter, mimeType) {
+			return true
+		}
+		// 支持通配符匹配，如 "video/*" 或 "audio/*"
+		if strings.HasSuffix(filter, "/*") {
+			prefix := strings.TrimSuffix(filter, "/*")
+			if strings.HasPrefix(strings.ToLower(mimeType), strings.ToLower(prefix)+"/") {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+// createAPI 创建新的API实例
+func (p *WebRTCPlugin) createAPI(ssd *sdp.SessionDescription) (api *API, err error) {
+	m := p.createMediaEngine(ssd)
 	i := &interceptor.Registry{}
+
+	// 注册默认拦截器
+	if err := RegisterDefaultInterceptors(m, i); err != nil {
+		p.Error("register default interceptors error", "error", err)
+		return nil, err
+	}
+
+	// 创建API
+	api = NewAPI(WithMediaEngine(m), WithInterceptorRegistry(i), WithSettingEngine(p.s))
+	return
+}
+
+// initSettingEngine 初始化SettingEngine
+func (p *WebRTCPlugin) initSettingEngine() error {
+	// 设置LoggerFactory
+	p.s.LoggerFactory = p
+
+	// 配置NAT 1:1 IP映射
 	if p.GetCommonConf().PublicIP != "" {
 		ips := []string{p.GetCommonConf().PublicIP}
 		if p.GetCommonConf().PublicIPv6 != "" {
@@ -90,6 +295,17 @@ func (p *WebRTCPlugin) OnInit() (err error) {
 		}
 		p.s.SetNAT1To1IPs(ips, ICECandidateTypeHost)
 	}
+
+	// 配置端口
+	if err := p.configurePort(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// configurePort 配置端口设置
+func (p *WebRTCPlugin) configurePort() error {
 	ports, err := ParsePort2(p.Port)
 	if err != nil {
 		p.Error("webrtc port config error", "error", err, "port", p.Port)
@@ -135,11 +351,41 @@ func (p *WebRTCPlugin) OnInit() (err error) {
 		p.s.SetICEUDPMux(NewICEUDPMux(nil, udpListener))
 		p.s.SetNetworkTypes([]NetworkType{NetworkTypeUDP4, NetworkTypeUDP6})
 	}
-	if err = RegisterDefaultInterceptors(&p.m, i); err != nil {
+
+	return nil
+}
+
+func (p *WebRTCPlugin) CreatePC(sd SessionDescription, conf Configuration) (pc *PeerConnection, err error) {
+	var ssd *sdp.SessionDescription
+	ssd, err = sd.Unmarshal()
+	if err != nil {
+		return
+	}
+	var api *API
+	// 创建PeerConnection并设置高级配置
+	api, err = p.createAPI(ssd)
+	if err != nil {
+		return
+	}
+	pc, err = api.NewPeerConnection(conf)
+	if err == nil {
+		err = pc.SetRemoteDescription(sd)
+	}
+	return
+}
+
+func (p *WebRTCPlugin) OnInit() (err error) {
+	if len(p.ICEServers) > 0 {
+		for i := range p.ICEServers {
+			b, _ := p.ICEServers[i].MarshalJSON()
+			p.ICEServers[i].UnmarshalJSON(b)
+		}
+	}
+
+	if err = p.initSettingEngine(); err != nil {
 		return err
 	}
-	p.api = NewAPI(WithMediaEngine(&p.m),
-		WithInterceptorRegistry(i), WithSettingEngine(p.s))
+
 	_, port, _ := strings.Cut(p.GetCommonConf().HTTP.ListenAddr, ":")
 	if port == "80" {
 		p.PushAddr = append(p.PushAddr, "http://{hostName}/webrtc/push")
@@ -203,8 +449,12 @@ func (p *WebRTCPlugin) testPage(w http.ResponseWriter, r *http.Request) {
 func (p *WebRTCPlugin) Pull(streamPath string, conf config.Pull, pubConf *config.Publish) {
 	if strings.HasPrefix(conf.URL, "https://rtc.live.cloudflare.com") {
 		cfClient := NewCFClient(DIRECTION_PULL)
-		var err error
-		cfClient.PeerConnection, err = p.api.NewPeerConnection(Configuration{
+		api, err := p.createAPI(nil)
+		if err != nil {
+			p.Error("create API failed", "error", err)
+			return
+		}
+		cfClient.PeerConnection, err = api.NewPeerConnection(Configuration{
 			ICEServers:   p.ICEServers,
 			BundlePolicy: BundlePolicyMaxBundle,
 		})

plugin/webrtc/pkg/batcher.go

@@ -13,6 +13,9 @@ const (
 	SignalTypeUnpublish     SignalType = "unpublish"
 	SignalTypeAnswer        SignalType = "answer"
 	SignalTypeGetStreamList SignalType = "getStreamList"
+	SignalTypePing          SignalType = "ping"
+	SignalTypePong          SignalType = "pong"
+	SignalTypeError         SignalType = "error"
 )
 
 type Signal struct {

plugin/webrtc/pkg/client.go

@@ -2,6 +2,7 @@ package webrtc
 
 import (
 	"m7s.live/v5"
+	"m7s.live/v5/pkg/config"
 )
 
 const (
@@ -31,7 +32,7 @@ func (c *Client) GetPushJob() *m7s.PushJob {
 	return &c.pushCtx
 }
 
-func NewPuller() m7s.IPuller {
+func NewPuller(config.Pull) m7s.IPuller {
 	return &Client{
 		direction: DIRECTION_PULL,
 	}

plugin/webrtc/pkg/config.go

@@ -4,7 +4,17 @@ import (
 	. "github.com/pion/webrtc/v4"
 )
 
-func RegisterCodecs(m *MediaEngine) error {
+var videoRTCPFeedback = []RTCPFeedback{{"goog-remb", ""}, {"ccm", "fir"}, {"nack", ""}, {"nack", "pli"}, {"transport-cc", ""}}
+
+type CodecWithType struct {
+	Codec RTPCodecParameters
+	Type  RTPCodecType
+}
+
+func GetDefaultCodecs() ([]CodecWithType, error) {
+	var codecs []CodecWithType
+
+	// 音频编解码器
 	for _, codec := range []RTPCodecParameters{
 		{
 			RTPCodecCapability: RTPCodecCapability{MimeTypePCMU, 8000, 0, "", nil},
@@ -14,12 +24,15 @@ func RegisterCodecs(m *MediaEngine) error {
 			RTPCodecCapability: RTPCodecCapability{MimeTypePCMA, 8000, 0, "", nil},
 			PayloadType:        8,
 		},
+		{
+			RTPCodecCapability: RTPCodecCapability{MimeTypeOpus, 48000, 2, "minptime=10;useinbandfec=1", nil},
+			PayloadType:        111,
+		},
 	} {
-		if err := m.RegisterCodec(codec, RTPCodecTypeAudio); err != nil {
-			return err
-		}
+		codecs = append(codecs, CodecWithType{Codec: codec, Type: RTPCodecTypeAudio})
 	}
-	videoRTCPFeedback := []RTCPFeedback{{"goog-remb", ""}, {"ccm", "fir"}, {"nack", ""}, {"nack", "pli"}}
+
+	// 视频编解码器
 	for _, codec := range []RTPCodecParameters{
 		// {
 		// 	RTPCodecCapability: RTPCodecCapability{"video/rtx", 90000, 0, "apt=96", nil},
@@ -95,10 +108,28 @@ func RegisterCodecs(m *MediaEngine) error {
 			RTPCodecCapability: RTPCodecCapability{MimeTypeH265, 90000, 0, "level-id=180;profile-id=1;tier-flag=0;tx-mode=SRST", videoRTCPFeedback},
 			PayloadType:        49,
 		},
+		{
+			RTPCodecCapability: RTPCodecCapability{MimeTypeH265, 90000, 0, "level-id=186;profile-id=1;tier-flag=0;tx-mode=SRST", videoRTCPFeedback},
+			PayloadType:        50,
+		},
+		{
+			RTPCodecCapability: RTPCodecCapability{MimeTypeH265, 90000, 0, "level-id=180;profile-id=2;tier-flag=0;tx-mode=SRST", videoRTCPFeedback},
+			PayloadType:        51,
+		},
+		{
+			RTPCodecCapability: RTPCodecCapability{MimeTypeH265, 90000, 0, "level-id=186;profile-id=2;tier-flag=0;tx-mode=SRST", videoRTCPFeedback},
+			PayloadType:        52,
+		},
+		{
+			RTPCodecCapability: RTPCodecCapability{MimeTypeVP9, 90000, 0, "", nil},
+			PayloadType:        100,
+		},
+		{
+			RTPCodecCapability: RTPCodecCapability{MimeTypeAV1, 90000, 0, "profile=2;level-idx=8;tier=1", nil},
+			PayloadType:        45,
+		},
 	} {
-		if err := m.RegisterCodec(codec, RTPCodecTypeVideo); err != nil {
-			return err
-		}
+		codecs = append(codecs, CodecWithType{Codec: codec, Type: RTPCodecTypeVideo})
 	}
-	return nil
+	return codecs, nil
 }

plugin/webrtc/pkg/connection.go

@@ -241,7 +241,7 @@ func (IO *MultipleConnection) SendSubscriber(subscriber *m7s.Subscriber) (audioS
 				return
 			}
 		}
-
+		rcc.RTCPFeedback = videoRTCPFeedback
 		videoTLSRTP, err = NewTrackLocalStaticRTP(rcc.RTPCodecCapability, videoCodec.String(), subscriber.StreamPath)
 		if err != nil {
 			return
@@ -452,32 +452,6 @@ type SingleConnection struct {
 	Connection
 }
 
-func (c *SingleConnection) Start() (err error) {
-	c.OnICECandidate(func(ice *ICECandidate) {
-		if ice != nil {
-			c.Info(ice.ToJSON().Candidate)
-		}
-	})
-	// 监听ICE连接状态变化
-	c.OnICEConnectionStateChange(func(state ICEConnectionState) {
-		c.Debug("ICE connection state changed", "state", state.String())
-		if state == ICEConnectionStateFailed {
-			c.Error("ICE connection failed")
-		}
-	})
-
-	c.OnConnectionStateChange(func(state PeerConnectionState) {
-		c.Info("Connection State has changed:" + state.String())
-		switch state {
-		case PeerConnectionStateConnected:
-
-		case PeerConnectionStateDisconnected, PeerConnectionStateFailed, PeerConnectionStateClosed:
-			c.Stop(errors.New("connection state:" + state.String()))
-		}
-	})
-	return
-}
-
 func (c *SingleConnection) Receive() {
 	c.OnTrack(func(track *TrackRemote, receiver *RTPReceiver) {
 		c.Info("OnTrack", "kind", track.Kind().String(), "payloadType", uint8(track.Codec().PayloadType))

prometheus.go

@@ -76,13 +76,10 @@ func (s *Server) Collect(ch chan<- prometheus.Metric) {
 			ch <- prometheus.MustNewConstMetric(s.prometheusDesc.Net.ReceiveSpeed, prometheus.GaugeValue, float64(net.ReceiveSpeed), net.Name)
 		}
 	}
-	s.Call(func() error {
-		for stream := range s.Streams.Range {
-			ch <- prometheus.MustNewConstMetric(s.prometheusDesc.BPS, prometheus.GaugeValue, float64(stream.VideoTrack.AVTrack.BPS), stream.StreamPath, stream.Plugin.Meta.Name, "video")
-			ch <- prometheus.MustNewConstMetric(s.prometheusDesc.FPS, prometheus.GaugeValue, float64(stream.VideoTrack.AVTrack.FPS), stream.StreamPath, stream.Plugin.Meta.Name, "video")
-			ch <- prometheus.MustNewConstMetric(s.prometheusDesc.BPS, prometheus.GaugeValue, float64(stream.AudioTrack.AVTrack.BPS), stream.StreamPath, stream.Plugin.Meta.Name, "audio")
-			ch <- prometheus.MustNewConstMetric(s.prometheusDesc.FPS, prometheus.GaugeValue, float64(stream.AudioTrack.AVTrack.FPS), stream.StreamPath, stream.Plugin.Meta.Name, "audio")
-		}
-		return nil
-	})
+	for stream := range s.Streams.SafeRange {
+		ch <- prometheus.MustNewConstMetric(s.prometheusDesc.BPS, prometheus.GaugeValue, float64(stream.VideoTrack.AVTrack.BPS), stream.StreamPath, stream.Plugin.Meta.Name, "video")
+		ch <- prometheus.MustNewConstMetric(s.prometheusDesc.FPS, prometheus.GaugeValue, float64(stream.VideoTrack.AVTrack.FPS), stream.StreamPath, stream.Plugin.Meta.Name, "video")
+		ch <- prometheus.MustNewConstMetric(s.prometheusDesc.BPS, prometheus.GaugeValue, float64(stream.AudioTrack.AVTrack.BPS), stream.StreamPath, stream.Plugin.Meta.Name, "audio")
+		ch <- prometheus.MustNewConstMetric(s.prometheusDesc.FPS, prometheus.GaugeValue, float64(stream.AudioTrack.AVTrack.FPS), stream.StreamPath, stream.Plugin.Meta.Name, "audio")
+	}
 }

publisher.go

@@ -1,6 +1,8 @@
 package m7s
 
 import (
+	"context"
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -314,6 +316,28 @@ func (p *Publisher) trackAdded() error {
 	return nil
 }
 
+func (p *Publisher) SetCodecCtx(ctx codec.ICodecCtx, data IAVFrame) {
+	if _, ok := ctx.(IAudioCodecCtx); ok {
+		t := p.AudioTrack.AVTrack
+		if t == nil {
+			t = NewAVTrack(data, p.Logger.With("track", "audio"), &p.Publish, p.audioReady)
+			p.AudioTrack.Set(t)
+			p.Call(p.trackAdded)
+		}
+		t.ICodecCtx = ctx
+		return
+	} else if _, ok := ctx.(IVideoCodecCtx); ok {
+		t := p.VideoTrack.AVTrack
+		if t == nil {
+			t = NewAVTrack(data, p.Logger.With("track", "video"), &p.Publish, p.videoReady)
+			p.VideoTrack.Set(t)
+			p.Call(p.trackAdded)
+		}
+		t.ICodecCtx = ctx
+		return
+	}
+}
+
 func (p *Publisher) WriteVideo(data IAVFrame) (err error) {
 	defer func() {
 		if err != nil {
@@ -628,18 +652,36 @@ func (p *Publisher) takeOver(old *Publisher) {
 	old.Subscribers = SubscriberCollection{}
 }
 
-func (p *Publisher) WaitTrack() (err error) {
+func (p *Publisher) WaitTrack(audio, video bool) error {
 	var v, a = pkg.ErrNoTrack, pkg.ErrNoTrack
-	if p.PubVideo {
-		v = p.videoReady.Await()
-	}
-	if p.PubAudio {
-		a = p.audioReady.Await()
+	// wait any track
+	if p.PubAudio && p.PubVideo && !audio && !video {
+		select {
+		case <-p.videoReady.Done():
+			v = context.Cause(p.videoReady.Context)
+			if errors.Is(v, util.ErrResolve) {
+				v = nil
+			}
+		case <-p.audioReady.Done():
+			v = context.Cause(p.audioReady.Context)
+			if errors.Is(v, util.ErrResolve) {
+				v = nil
+			}
+		}
+	} else {
+		// need wait video
+		if p.PubVideo && video {
+			v = p.videoReady.Await()
+		}
+		// need wait audio
+		if p.PubAudio && audio {
+			a = p.audioReady.Await()
+		}
 	}
 	if v != nil && a != nil {
 		return ErrNoTrack
 	}
-	return
+	return nil
 }
 
 func (p *Publisher) NoVideo() {

pull_proxy.go

@@ -6,6 +6,7 @@ import (
 	"net"
 	"net/url"
 	"path/filepath"
+	"regexp"
 	"strings"
 	"time"
 
@@ -107,7 +108,7 @@ func (d *BasePullProxy) ChangeStatus(status byte) {
 	}
 	switch status {
 	case PullProxyStatusOnline:
-		if d.PullOnStart && from == PullProxyStatusOffline {
+		if d.PullOnStart && (from == PullProxyStatusOffline) {
 			d.Pull()
 		}
 	}
@@ -197,7 +198,7 @@ func (d *TCPPullProxy) Tick(any) {
 
 func (p *Publisher) processPullProxyOnStart() {
 	s := p.Plugin.Server
-	if pullProxy, ok := s.PullProxies.Find(func(pullProxy IPullProxy) bool {
+	if pullProxy, ok := s.PullProxies.SafeFind(func(pullProxy IPullProxy) bool {
 		return pullProxy.GetStreamPath() == p.StreamPath
 	}); ok {
 		p.PullProxyConfig = pullProxy.GetConfig()
@@ -213,7 +214,7 @@ func (p *Publisher) processPullProxyOnStart() {
 func (p *Publisher) processPullProxyOnDispose() {
 	s := p.Plugin.Server
 	if p.PullProxyConfig != nil && p.PullProxyConfig.Status == PullProxyStatusPulling {
-		if pullproxy, ok := s.PullProxies.Get(p.PullProxyConfig.GetKey()); ok {
+		if pullproxy, ok := s.PullProxies.SafeGet(p.PullProxyConfig.GetKey()); ok {
 			pullproxy.ChangeStatus(PullProxyStatusOnline)
 		}
 	}
@@ -260,7 +261,7 @@ func (s *Server) GetPullProxyList(ctx context.Context, req *emptypb.Empty) (res
 }
 
 func (s *Server) AddPullProxy(ctx context.Context, req *pb.PullProxyInfo) (res *pb.SuccessResponse, err error) {
-	device := &PullProxyConfig{
+	pullProxyConfig := &PullProxyConfig{
 		Name:        req.Name,
 		Type:        req.Type,
 		ParentID:    uint(req.ParentID),
@@ -268,7 +269,7 @@ func (s *Server) AddPullProxy(ctx context.Context, req *pb.PullProxyInfo) (res *
 		Description: req.Description,
 		StreamPath:  req.StreamPath,
 	}
-	if device.Type == "" {
+	if pullProxyConfig.Type == "" {
 		var u *url.URL
 		u, err = url.Parse(req.PullURL)
 		if err != nil {
@@ -277,35 +278,55 @@ func (s *Server) AddPullProxy(ctx context.Context, req *pb.PullProxyInfo) (res *
 		}
 		switch u.Scheme {
 		case "srt", "rtsp", "rtmp":
-			device.Type = u.Scheme
+			pullProxyConfig.Type = u.Scheme
 		default:
 			ext := filepath.Ext(u.Path)
 			switch ext {
 			case ".m3u8":
-				device.Type = "hls"
+				pullProxyConfig.Type = "hls"
 			case ".flv":
-				device.Type = "flv"
+				pullProxyConfig.Type = "flv"
 			case ".mp4":
-				device.Type = "mp4"
+				pullProxyConfig.Type = "mp4"
+			default:
+				pattern := `^\d{20}/\d{20}$`
+				re := regexp.MustCompile(pattern)
+				if re.MatchString(u.Path) {
+					pullProxyConfig.Type = "gb28181"
+				}
 			}
 		}
 	}
-	defaults.SetDefaults(&device.Pull)
-	defaults.SetDefaults(&device.Record)
-	device.URL = req.PullURL
-	device.Audio = req.Audio
-	device.StopOnIdle = req.StopOnIdle
-	device.Record.FilePath = req.RecordPath
-	device.Record.Fragment = req.RecordFragment.AsDuration()
+	defaults.SetDefaults(&pullProxyConfig.Pull)
+	defaults.SetDefaults(&pullProxyConfig.Record)
+	pullProxyConfig.URL = req.PullURL
+	pullProxyConfig.Audio = req.Audio
+	pullProxyConfig.StopOnIdle = req.StopOnIdle
+	pullProxyConfig.Record.FilePath = req.RecordPath
+	pullProxyConfig.Record.Fragment = req.RecordFragment.AsDuration()
 	if s.DB == nil {
 		err = pkg.ErrNoDB
 		return
 	}
-	s.DB.Create(device)
-	if req.StreamPath == "" {
-		device.StreamPath = device.GetStreamPath()
+
+	// 检查数据库中是否有相同的 streamPath 且状态不是 disabled 的记录
+	var existingCount int64
+	streamPath := pullProxyConfig.StreamPath
+	if streamPath == "" {
+		streamPath = pullProxyConfig.GetStreamPath()
 	}
-	_, err = s.createPullProxy(device)
+	s.DB.Model(&PullProxyConfig{}).Where("stream_path = ? AND status != ?", streamPath, PullProxyStatusDisabled).Count(&existingCount)
+
+	// 如果存在相同 streamPath 且状态不是 disabled 的记录，将当前记录状态设置为 disabled
+	if existingCount > 0 {
+		pullProxyConfig.Status = PullProxyStatusDisabled
+	}
+
+	s.DB.Create(pullProxyConfig)
+	if req.StreamPath == "" {
+		pullProxyConfig.StreamPath = pullProxyConfig.GetStreamPath()
+	}
+	_, err = s.createPullProxy(pullProxyConfig)
 
 	res = &pb.SuccessResponse{}
 	return
@@ -321,6 +342,10 @@ func (s *Server) UpdatePullProxy(ctx context.Context, req *pb.PullProxyInfo) (re
 	if err != nil {
 		return
 	}
+
+	// 记录原始状态，用于后续判断状态变化
+	originalStatus := target.Status
+
 	target.Name = req.Name
 	target.URL = req.PullURL
 	target.ParentID = uint(req.ParentID)
@@ -355,19 +380,50 @@ func (s *Server) UpdatePullProxy(ctx context.Context, req *pb.PullProxyInfo) (re
 	target.Record.Fragment = req.RecordFragment.AsDuration()
 	target.RTT = time.Duration(int(req.Rtt)) * time.Millisecond
 	target.StreamPath = req.StreamPath
+
+	// 如果设置状态为非 disable，需要检查是否有相同 streamPath 的其他非 disable 代理
+	if req.Status != uint32(PullProxyStatusDisabled) {
+		var existingCount int64
+		streamPath := target.StreamPath
+		if streamPath == "" {
+			streamPath = target.GetStreamPath()
+		}
+		s.DB.Model(&PullProxyConfig{}).Where("stream_path = ? AND id != ? AND status != ?", streamPath, req.ID, PullProxyStatusDisabled).Count(&existingCount)
+
+		// 如果存在相同 streamPath 且状态不是 disabled 的其他记录，更新失败
+		if existingCount > 0 {
+			err = fmt.Errorf("已存在相同 streamPath [%s] 的非禁用代理，更新失败", streamPath)
+			return
+		}
+		target.Status = byte(req.Status)
+	} else {
+		target.Status = PullProxyStatusDisabled
+	}
+
 	s.DB.Save(target)
+
+	// 检查是否从 disable 状态变为非 disable 状态
+	wasDisabled := originalStatus == PullProxyStatusDisabled
+	isNowEnabled := target.Status != PullProxyStatusDisabled
+	isNowDisabled := target.Status == PullProxyStatusDisabled
+	wasEnabled := originalStatus != PullProxyStatusDisabled
+
 	if device, ok := s.PullProxies.SafeGet(uint(req.ID)); ok {
+		// 如果现在变为 disable 状态，需要停止并移除代理
+		if wasEnabled && isNowDisabled {
+			device.Stop(task.ErrStopByUser)
+			return
+		}
+
 		conf := device.GetConfig()
 		if target.URL != conf.URL || conf.Audio != target.Audio || conf.StreamPath != target.StreamPath || conf.Record.FilePath != target.Record.FilePath || conf.Record.Fragment != target.Record.Fragment {
 			device.Stop(task.ErrStopByUser)
-			device.WaitStopped()
-			_, err = s.createPullProxy(target)
+			device, err = s.createPullProxy(target)
 			if target.Status == PullProxyStatusPulling {
 				if pullJob, ok := s.Pulls.SafeGet(device.GetStreamPath()); ok {
+					pullJob.OnDispose(device.Pull)
 					pullJob.Stop(task.ErrStopByUser)
-					pullJob.WaitStopped()
 				}
-				device.Pull()
 			}
 		} else {
 			conf.Name = target.Name
@@ -382,6 +438,12 @@ func (s *Server) UpdatePullProxy(ctx context.Context, req *pb.PullProxyInfo) (re
 				}
 			}
 		}
+	} else if wasDisabled && isNowEnabled {
+		// 如果原来是 disable 现在不是了，需要创建 PullProxy 并添加到集合中
+		_, err = s.createPullProxy(target)
+		if err != nil {
+			s.Error("create pull proxy failed", "error", err)
+		}
 	}
 	res = &pb.SuccessResponse{}
 	return
@@ -426,3 +488,12 @@ func (s *Server) RemovePullProxy(ctx context.Context, req *pb.RequestWithId) (re
 		return
 	}
 }
+
+func (p *PullProxyManager) CheckToPull(streamPath string) {
+	for pullProxy := range p.SafeRange {
+		conf := pullProxy.GetConfig()
+		if conf.Status == PullProxyStatusOnline && pullProxy.GetStreamPath() == streamPath {
+			pullProxy.Pull()
+		}
+	}
+}

puller.go

@@ -238,7 +238,6 @@ func (p *RecordFilePuller) queryRecordStreams(startTime, endTime time.Time) (err
 		return pkg.ErrNoDB
 	}
 	queryRecord := RecordStream{
-		Mode: RecordModeAuto,
 		Type: p.Type,
 	}
 	tx := p.PullJob.Plugin.DB.Where(&queryRecord).Find(&p.Streams, "end_time>=? AND start_time<=? AND stream_path=?", startTime, endTime, p.PullJob.RemoteURL)

recoder.go

@@ -1,6 +1,8 @@
 package m7s
 
 import (
+	"os"
+	"path/filepath"
 	"time"
 
 	"gorm.io/gorm"
@@ -12,57 +14,46 @@ import (
 	"m7s.live/v5/pkg"
 )
 
-const (
-	RecordModeAuto  RecordMode = "auto"
-	RecordModeEvent RecordMode = "event"
-	EventLevelLow   EventLevel = "low"
-	EventLevelHigh  EventLevel = "high"
-)
-
 type (
-	EventLevel = string
-	RecordMode = string
-	IRecorder  interface {
+	IRecorder interface {
 		task.ITask
 		GetRecordJob() *RecordJob
 	}
 	RecorderFactory = func(config.Record) IRecorder
-	RecordJob       struct {
+	// RecordEvent 包含录像事件的公共字段
+
+	EventRecordStream struct {
+		*config.RecordEvent
+		RecordStream
+	}
+	RecordJob struct {
 		task.Job
-		StreamPath     string // 对应本地流
-		Plugin         *Plugin
-		Subscriber     *Subscriber
-		SubConf        *config.Subscribe
-		RecConf        *config.Record
-		recorder       IRecorder
-		EventId        string        `json:"eventId" desc:"事件编号"`
-		Mode           RecordMode    `json:"mode" desc:"事件类型,auto=连续录像模式，event=事件录像模式"`
-		BeforeDuration time.Duration `json:"beforeDuration" desc:"事件前缓存时长"`
-		AfterDuration  time.Duration `json:"afterDuration" desc:"事件后缓存时长"`
-		EventDesc      string        `json:"eventDesc" desc:"事件描述"`
-		EventLevel     EventLevel    `json:"eventLevel" desc:"事件级别"`
-		EventName      string        `json:"eventName" desc:"事件名称"`
+		Event      *config.RecordEvent
+		StreamPath string // 对应本地流
+		Plugin     *Plugin
+		Subscriber *Subscriber
+		SubConf    *config.Subscribe
+		RecConf    *config.Record
+		recorder   IRecorder
 	}
 	DefaultRecorder struct {
 		task.Task
 		RecordJob RecordJob
+		Event     EventRecordStream
 	}
 	RecordStream struct {
-		ID                     uint          `gorm:"primarykey"`
-		StartTime, EndTime     time.Time     `gorm:"type:datetime;default:NULL"`
-		EventId                string        `json:"eventId" desc:"事件编号" gorm:"type:varchar(255);comment:事件编号"`
-		Mode                   RecordMode    `json:"mode" desc:"事件类型,auto=连续录像模式，event=事件录像模式" gorm:"type:varchar(255);comment:事件类型,auto=连续录像模式，event=事件录像模式;default:'auto'"`
-		EventName              string        `json:"eventName" desc:"事件名称" gorm:"type:varchar(255);comment:事件名称"`
-		BeforeDuration         time.Duration `json:"beforeDuration" desc:"事件前缓存时长" gorm:"type:BIGINT;comment:事件前缓存时长;default:30000000000"`
-		AfterDuration          time.Duration `json:"afterDuration" desc:"事件后缓存时长" gorm:"type:BIGINT;comment:事件后缓存时长;default:30000000000"`
-		Filename               string        `json:"fileName" desc:"文件名" gorm:"type:varchar(255);comment:文件名"`
-		EventDesc              string        `json:"eventDesc" desc:"事件描述" gorm:"type:varchar(255);comment:事件描述"`
-		Type                   string        `json:"type" desc:"录像文件类型" gorm:"type:varchar(255);comment:录像文件类型,flv,mp4,raw,fmp4,hls"`
-		EventLevel             EventLevel    `json:"eventLevel" desc:"事件级别" gorm:"type:varchar(255);comment:事件级别,high表示重要事件，无法删除且表示无需自动删除,low表示非重要事件,达到自动删除时间后，自动删除;default:'low'"`
-		FilePath               string
-		StreamPath             string
-		AudioCodec, VideoCodec string
-		DeletedAt              gorm.DeletedAt `gorm:"index" yaml:"-"`
+		ID         uint      `gorm:"primarykey"`
+		StartTime  time.Time `gorm:"default:NULL"`
+		EndTime    time.Time `gorm:"default:NULL"`
+		Duration   uint32    `gorm:"comment:录像时长;default:0"`
+		Filename   string    `json:"fileName" desc:"文件名" gorm:"type:varchar(255);comment:文件名"`
+		Type       string    `json:"type" desc:"录像文件类型" gorm:"type:varchar(255);comment:录像文件类型,flv,mp4,raw,fmp4,hls"`
+		FilePath   string
+		StreamPath string
+		AudioCodec string
+		VideoCodec string
+		CreatedAt  time.Time
+		DeletedAt  gorm.DeletedAt `gorm:"index" yaml:"-"`
 	}
 )
 
@@ -74,6 +65,52 @@ func (r *DefaultRecorder) Start() (err error) {
 	return r.RecordJob.Subscribe()
 }
 
+func (r *DefaultRecorder) CreateStream(start time.Time, customFileName func(*RecordJob) string) (err error) {
+	recordJob := &r.RecordJob
+	sub := recordJob.Subscriber
+	r.Event.RecordStream = RecordStream{
+		StartTime:  start,
+		StreamPath: sub.StreamPath,
+		FilePath:   customFileName(recordJob),
+		Type:       recordJob.RecConf.Type,
+	}
+	dir := filepath.Dir(r.Event.FilePath)
+	if err = os.MkdirAll(dir, 0755); err != nil {
+		return
+	}
+	if sub.Publisher.HasAudioTrack() {
+		r.Event.AudioCodec = sub.Publisher.AudioTrack.ICodecCtx.String()
+	}
+	if sub.Publisher.HasVideoTrack() {
+		r.Event.VideoCodec = sub.Publisher.VideoTrack.ICodecCtx.String()
+	}
+	if recordJob.Plugin.DB != nil {
+		if recordJob.Event != nil {
+			r.Event.RecordEvent = recordJob.Event
+			recordJob.Plugin.DB.Save(&r.Event)
+		} else {
+			recordJob.Plugin.DB.Save(&r.Event.RecordStream)
+		}
+	}
+	return
+}
+
+func (r *DefaultRecorder) WriteTail(end time.Time, tailJob task.IJob) {
+	r.Event.EndTime = end
+	if r.RecordJob.Plugin.DB != nil {
+		// 将事件和录像记录关联
+		if r.RecordJob.Event != nil {
+			r.RecordJob.Plugin.DB.Save(&r.Event)
+		} else {
+			r.RecordJob.Plugin.DB.Save(&r.Event.RecordStream)
+		}
+	}
+	if tailJob == nil {
+		return
+	}
+	tailJob.AddTask(NewEventRecordCheck(r.Event.Type, r.Event.StreamPath, r.RecordJob.Plugin.DB))
+}
+
 func (p *RecordJob) GetKey() string {
 	return p.RecConf.FilePath
 }
@@ -149,3 +186,27 @@ func (p *RecordJob) Start() (err error) {
 	p.AddTask(p.recorder, p.Logger)
 	return
 }
+
+func NewEventRecordCheck(t string, streamPath string, db *gorm.DB) *eventRecordCheck {
+	return &eventRecordCheck{
+		DB:         db,
+		streamPath: streamPath,
+		Type:       t,
+	}
+}
+
+type eventRecordCheck struct {
+	task.Task
+	DB         *gorm.DB
+	streamPath string
+	Type       string
+}
+
+func (t *eventRecordCheck) Run() (err error) {
+	var eventRecordStreams []EventRecordStream
+	t.DB.Find(&eventRecordStreams, `type=? AND event_level='high' AND stream_path=?`, t.Type, t.streamPath) //搜索事件录像，且为重要事件（无法自动删除）
+	for _, recordStream := range eventRecordStreams {
+		t.DB.Model(&EventRecordStream{}).Where(`event_level='low' AND start_time <= ? and end_time >= ?`, recordStream.EndTime, recordStream.StartTime).Update("event_level", config.EventLevelHigh)
+	}
+	return
+}

scripts/packet_replayer.py

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+import argparse
+from scapy.all import rdpcap, IP, TCP, UDP, Raw, send, sr1, sr, PcapReader
+import sys
+import time
+from collections import defaultdict
+import random
+import threading
+import queue
+import socket
+import heapq
+
+class PacketReplayer:
+    def __init__(self, pcap_file, target_ip, target_port):
+        self.pcap_file = pcap_file
+        self.target_ip = target_ip
+        self.target_port = target_port
+        self.connections = defaultdict(list)  # 存储每个连接的包序列
+        self.response_queue = queue.Queue()
+        self.stop_reading = threading.Event()
+        self.socket = None
+        self.next_seq = None  # 下一个期望的序列号
+        self.pending_packets = []  # 使用优先队列存储待发送的包
+        self.seen_packets = set()  # 用于去重
+        self.initial_seq = None  # 初始序列号
+        self.initial_ack = None  # 初始确认号
+        self.client_ip = None  # 客户端IP
+        self.client_port = None  # 客户端端口
+        self.first_data_packet = True  # 标记是否是第一个数据包
+        self.total_packets_sent = 0  # 发送的数据包数量
+        self.total_bytes_sent = 0  # 发送的总字节数
+        # 添加时间控制相关属性
+        self.first_packet_time = None  # 第一个包的时间戳
+        self.use_original_timing = True  # 是否使用原始时间间隔
+        self.last_packet_time = None  # 上一个包的时间戳
+
+    def establish_tcp_connection(self, src_port):
+        """建立TCP连接"""
+        print(f"正在建立TCP连接 {self.target_ip}:{self.target_port}...")
+        try:
+            self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            # 不绑定源端口，让系统自动分配
+            self.socket.settimeout(5)
+            self.socket.connect((self.target_ip, self.target_port))
+            actual_port = self.socket.getsockname()[1]
+            print(f"使用本地端口: {actual_port}")
+            print("TCP连接已建立")
+            return True
+        except Exception as e:
+            print(f"建立连接失败: {e}")
+            if self.socket:
+                self.socket.close()
+                self.socket = None
+            return False
+
+    def process_packet(self, packet, src_ip=None, src_port=None, protocol=None):
+        """处理单个数据包"""
+        if IP not in packet:
+            return
+
+        if src_ip and packet[IP].src != src_ip:
+            return
+
+        if protocol == 'tcp' and TCP in packet:
+            if src_port and packet[TCP].sport != src_port:
+                return
+            conn_id = (packet[IP].src, packet[TCP].sport)
+            self.connections[conn_id].append(packet)
+        elif protocol == 'udp' and UDP in packet:
+            if src_port and packet[UDP].sport != src_port:
+                return
+            conn_id = (packet[IP].src, packet[UDP].sport)
+            self.connections[conn_id].append(packet)
+        elif not protocol:
+            if TCP in packet:
+                if src_port and packet[TCP].sport != src_port:
+                    return
+                conn_id = (packet[IP].src, packet[TCP].sport)
+                self.connections[conn_id].append(packet)
+            elif UDP in packet:
+                if src_port and packet[UDP].sport != src_port:
+                    return
+                conn_id = (packet[IP].src, packet[UDP].sport)
+                self.connections[conn_id].append(packet)
+
+    def send_packet(self, packet, packet_count):
+        """发送单个数据包，处理序列号"""
+        if TCP not in packet or IP not in packet:
+            return True
+
+        try:
+            # 检查是否是发送到目标端口的包
+            if packet[TCP].dport == self.target_port:
+                # 记录客户端信息
+                if self.client_ip is None:
+                    self.client_ip = packet[IP].src
+                    self.client_port = packet[TCP].sport
+                    print(f"识别到客户端: {self.client_ip}:{self.client_port}")
+
+                # 获取TCP序列号和确认号
+                seq = packet[TCP].seq
+                ack = packet[TCP].ack
+                flags = packet[TCP].flags
+
+                # 打印数据包信息
+                print(f"[序号:{packet_count}] 处理数据包: src={packet[IP].src}:{packet[TCP].sport} -> dst={packet[IP].dst}:{packet[TCP].dport}, seq={seq}, ack={ack}, flags={flags}")
+
+                # 发送当前包
+                if Raw in packet:
+                    # 如果是第一个数据包，记录初始序列号
+                    if self.first_data_packet:
+                        self.initial_seq = seq
+                        self.next_seq = seq
+                        self.first_data_packet = False
+                        print(f"第一个数据包，初始序列号: {seq}")
+
+                    # 如果是重传包，跳过
+                    if seq in self.seen_packets:
+                        print(f"跳过重传包，序列号: {seq}")
+                        return True
+
+                    # 如果序列号大于期望的序列号，将包放入待发送队列
+                    if seq > self.next_seq:
+                        print(f"包乱序，放入队列，序列号: {seq}, 期望序列号: {self.next_seq}")
+                        heapq.heappush(self.pending_packets, (seq, packet))
+                        return True
+
+                    payload = packet[Raw].load
+                    print(f"准备发送数据包，负载大小: {len(payload)} 字节")
+                    self.socket.send(payload)
+                    self.seen_packets.add(seq)
+                    old_seq = self.next_seq
+                    self.next_seq = self.next_seq + len(payload)
+                    print(f"更新序列号: {old_seq} -> {self.next_seq}")
+                    
+                    # 更新统计信息
+                    self.total_packets_sent += 1
+                    self.total_bytes_sent += len(payload)
+                    
+                    # 检查并发送待发送队列中的包
+                    while self.pending_packets and self.pending_packets[0][0] == self.next_seq:
+                        _, next_packet = heapq.heappop(self.pending_packets)
+                        if Raw in next_packet:
+                            next_payload = next_packet[Raw].load
+                            print(f"发送队列中的包，负载大小: {len(next_payload)} 字节")
+                            self.socket.send(next_payload)
+                            self.seen_packets.add(self.next_seq)
+                            old_seq = self.next_seq
+                            self.next_seq += len(next_payload)
+                            print(f"更新序列号: {old_seq} -> {self.next_seq}")
+                            
+                            # 更新统计信息
+                            self.total_packets_sent += 1
+                            self.total_bytes_sent += len(next_payload)
+                    
+                    packet_time = time.strftime("%H:%M:%S", time.localtime(float(packet.time)))
+                    print(f"[{packet_time}] [序号:{packet_count}] 已发送数据包 (序列号: {seq}, 负载大小: {len(payload)} 字节)")
+                else:
+                    # 对于控制包，只记录到已处理集合
+                    if flags & 0x02:  # SYN
+                        print(f"[序号:{packet_count}] 处理SYN包")
+                    elif flags & 0x10:  # ACK
+                        print(f"[序号:{packet_count}] 处理ACK包")
+                    else:
+                        print(f"[序号:{packet_count}] 跳过无负载包")
+            else:
+                print(f"[序号:{packet_count}] 跳过非目标端口的包: src={packet[IP].src}:{packet[TCP].sport} -> dst={packet[IP].dst}:{packet[TCP].dport}")
+            return True
+        except Exception as e:
+            print(f"发送数据包 {packet_count} 时出错: {e}")
+            return False
+
+    def response_reader(self, src_port):
+        """持续读取服务器响应的线程函数"""
+        while not self.stop_reading.is_set() and self.socket:
+            try:
+                data = self.socket.recv(4096)
+                if data:
+                    self.response_queue.put(data)
+                    print(f"收到响应: {len(data)} 字节")
+            except socket.timeout:
+                continue
+            except Exception as e:
+                if not self.stop_reading.is_set():
+                    print(f"读取响应时出错: {e}")
+                break
+            time.sleep(0.1)
+
+    def replay_packets(self, src_ip=None, src_port=None, protocol=None, delay=0):
+        """边读取边重放数据包"""
+        print(f"开始读取并重放数据包到 {self.target_ip}:{self.target_port}")
+        print(f"使用原始时间间隔发送数据包")
+        
+        try:
+            reader = PcapReader(self.pcap_file)
+            packet_count = 0
+            connection_established = False
+            
+            for packet in reader:
+                packet_count += 1
+                
+                if IP not in packet:
+                    continue
+                    
+                if src_ip and packet[IP].src != src_ip:
+                    continue
+                    
+                current_src_port = None
+                if protocol == 'tcp' and TCP in packet:
+                    if src_port and packet[TCP].sport != src_port:
+                        continue
+                    current_src_port = packet[TCP].sport
+                elif protocol == 'udp' and UDP in packet:
+                    if src_port and packet[UDP].sport != src_port:
+                        continue
+                    current_src_port = packet[UDP].sport
+                elif not protocol:
+                    if TCP in packet:
+                        if src_port and packet[TCP].sport != src_port:
+                            continue
+                        current_src_port = packet[TCP].sport
+                    elif UDP in packet:
+                        if src_port and packet[UDP].sport != src_port:
+                            continue
+                        current_src_port = packet[UDP].sport
+                    else:
+                        continue
+                else:
+                    continue
+                
+                if not connection_established:
+                    if not self.establish_tcp_connection(current_src_port):
+                        print("无法建立连接，退出")
+                        return
+                    self.stop_reading.clear()
+                    reader_thread = threading.Thread(target=self.response_reader, args=(current_src_port,))
+                    reader_thread.daemon = True
+                    reader_thread.start()
+                    connection_established = True
+                
+                # 处理时间间隔
+                current_time = float(packet.time)
+                if self.first_packet_time is None:
+                    self.first_packet_time = current_time
+                    self.last_packet_time = current_time
+                elif self.use_original_timing:
+                    # 计算与上一个包的时间差
+                    time_diff = current_time - self.last_packet_time
+                    if time_diff > 0:
+                        print(f"等待 {time_diff:.3f} 秒后发送下一个包...")
+                        time.sleep(time_diff)
+                    self.last_packet_time = current_time
+                
+                if not self.send_packet(packet, packet_count):
+                    print("发送数据包失败，退出")
+                    return
+                
+                if delay > 0:
+                    time.sleep(delay)
+            
+            print(f"\n统计信息:")
+            print(f"总共处理了 {packet_count} 个数据包")
+            print(f"成功发送了 {self.total_packets_sent} 个数据包")
+            print(f"总共发送了 {self.total_bytes_sent} 字节数据")
+            if self.first_packet_time is not None:
+                total_time = float(self.last_packet_time - self.first_packet_time)
+                print(f"总耗时: {total_time:.3f} 秒")
+                print(f"平均发送速率: {self.total_bytes_sent / total_time:.2f} 字节/秒")
+            
+        except Exception as e:
+            print(f"处理数据包时出错: {e}")
+            sys.exit(1)
+        finally:
+            self.stop_reading.set()
+            if self.socket:
+                self.socket.close()
+                self.socket = None
+            reader.close()
+
+def main():
+    parser = argparse.ArgumentParser(description='Wireshark数据包重放工具')
+    parser.add_argument('pcap_file', help='pcap文件路径')
+    parser.add_argument('target_ip', help='目标IP地址')
+    parser.add_argument('target_port', type=int, help='目标端口')
+    parser.add_argument('--delay', type=float, default=0, help='数据包发送间隔(秒)')
+    parser.add_argument('--src-ip', help='过滤源IP地址')
+    parser.add_argument('--src-port', type=int, help='过滤源端口')
+    parser.add_argument('--protocol', choices=['tcp', 'udp'], help='过滤协议类型')
+
+    args = parser.parse_args()
+
+    replayer = PacketReplayer(args.pcap_file, args.target_ip, args.target_port)
+    replayer.replay_packets(args.src_ip, args.src_port, args.protocol, args.delay)
+
+if __name__ == '__main__':
+    main() 

server.go

@@ -277,6 +277,7 @@ func (s *Server) Start() (err error) {
 
 	s.registerHandler(map[string]http.HandlerFunc{
 		"/api/config/json/{name}":             s.api_Config_JSON_,
+		"/api/config/yaml/all":                s.api_Config_YAML_All,
 		"/api/stream/annexb/{streamPath...}":  s.api_Stream_AnnexB_,
 		"/api/videotrack/sse/{streamPath...}": s.api_VideoTrack_SSE,
 		"/api/audiotrack/sse/{streamPath...}": s.api_AudioTrack_SSE,
@@ -427,16 +428,23 @@ func (s *Server) Start() (err error) {
 				}
 			}
 		}
-		s.initDB()
+		if s.DB != nil {
+			s.initPullProxies()
+			s.initPushProxies()
+			s.initStreamAlias()
+		} else {
+			s.initPullProxiesWithoutDB()
+			s.initPushProxiesWithoutDB()
+		}
 		return nil
 	}, "serverStart")
 	return
 }
 
 func (s *Server) initPullProxies() {
-	// 1. First read all pull proxies from database
+	// 1. First read all pull proxies from database, excluding disabled ones
 	var pullProxies []*PullProxyConfig
-	s.DB.Find(&pullProxies)
+	s.DB.Where("status != ?", PullProxyStatusDisabled).Find(&pullProxies)
 
 	// Create a map for quick lookup of existing proxies
 	existingPullProxies := make(map[uint]*PullProxyConfig)
@@ -466,9 +474,11 @@ func (s *Server) initPullProxies() {
 		}
 	}
 
-	// 3. Finally add all proxies to collections
+	// 3. Finally add all proxies to collections, excluding disabled ones
 	for _, proxy := range pullProxies {
-		s.createPullProxy(proxy)
+		if proxy.Status != PullProxyStatusDisabled {
+			s.createPullProxy(proxy)
+		}
 	}
 }
 
@@ -532,18 +542,6 @@ func (s *Server) initPushProxiesWithoutDB() {
 	}
 }
 
-func (s *Server) initDB() {
-	if s.DB != nil {
-
-		s.initPullProxies()
-		s.initPushProxies()
-		s.initStreamAlias()
-	} else {
-		s.initPullProxiesWithoutDB()
-		s.initPushProxiesWithoutDB()
-	}
-}
-
 func (c *CheckSubWaitTimeout) GetTickInterval() time.Duration {
 	return c.s.PulseInterval
 }
@@ -582,12 +580,9 @@ func (s *Server) Dispose() {
 
 func (s *Server) GetPublisher(streamPath string) (publisher *Publisher, err error) {
 	var ok bool
-	s.Streams.Call(func() error {
-		publisher, ok = s.Streams.Get(streamPath)
-		return nil
-	})
+	publisher, ok = s.Streams.SafeGet(streamPath)
 	if !ok {
-		err = fmt.Errorf("src stream not found")
+		err = pkg.ErrNotFound
 		return
 	}
 	return
@@ -609,12 +604,7 @@ func (s *Server) OnSubscribe(streamPath string, args url.Values) {
 	for plugin := range s.Plugins.Range {
 		plugin.OnSubscribe(streamPath, args)
 	}
-	for pullProxy := range s.PullProxies.Range {
-		conf := pullProxy.GetConfig()
-		if conf.Status == PullProxyStatusOnline && pullProxy.GetStreamPath() == streamPath && !conf.PullOnStart {
-			pullProxy.Pull()
-		}
-	}
+	s.PullProxies.CheckToPull(streamPath)
 }
 
 func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {