feat: listener before ack,download progress

1.listener before ack
2.use ps.pts to update download progress

.cursor/rules/monibuca.mdc

@@ -0,0 +1,5 @@
+---
+description: build pb
+alwaysApply: false
+---
+如果修改了 proto 文件需要编译，请使用 scripts 目录下的脚本来编译

.github/FUNDING.yml

@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: monibuca
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/workflows/go.yml

@@ -0,0 +1,108 @@
+name: Go
+
+on:
+  create:
+    tags:
+      - 'v5*'
+env:
+  dest: bin
+jobs:
+
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    
+    - uses: actions/checkout@v2
+      with:
+          fetch-depth: 1
+
+    - name: Set up Env
+      run: echo "version=${GITHUB_REF:11}" >> $GITHUB_ENV
+    - name: Set beta
+      if: contains(env.version, 'beta')
+      run: echo "dest=beta" >> $GITHUB_ENV
+    - name: Set up Go
+      uses: actions/setup-go@v2
+      with:
+        go-version: 1.25.0
+
+    - name: Cache Go modules
+      uses: actions/cache@v4
+      with:
+        path: ~/go/pkg/mod
+        key: ${{ runner.os }}−go−${{ hashFiles('**/go.sum') }}
+
+    - name: Run GoReleaser
+      uses: goreleaser/goreleaser-action@v2
+      if: success() && startsWith(github.ref, 'refs/tags/')
+      with:
+        version: v1.8.3
+        args: release --rm-dist
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+    # - name: Checkout m7s-import
+    #   uses: actions/checkout@v3
+    #   with:
+    #     repository: langhuihui/m7s-import
+    #     path: m7s-import
+    #     persist-credentials: false # otherwise, the token used is the GITHUB_TOKEN, instead of your personal access token.
+    #     fetch-depth: 0
+
+    # - name: Add bin to m7s-import
+    #   if: success() && startsWith(github.ref, 'refs/tags/')
+    #   run:  |
+    #     cd m7s-import
+    #     mkdir -p apps/m7s-website/src/public/bin
+    #     cp ../dist/m7s_${{ env.version }}_windows_amd64.tar.gz apps/m7s-website/src/public/bin/m7s_windows_amd64.tar.gz
+    #     cp ../dist/m7s_${{ env.version }}_darwin_amd64.tar.gz  apps/m7s-website/src/public/bin/m7s_darwin_amd64.tar.gz 
+    #     cp ../dist/m7s_${{ env.version }}_darwin_arm64.tar.gz  apps/m7s-website/src/public/bin/m7s_darwin_arm64.tar.gz 
+    #     cp ../dist/m7s_${{ env.version }}_linux_amd64.tar.gz   apps/m7s-website/src/public/bin/m7s_linux_amd64.tar.gz 
+    #     cp ../dist/m7s_${{ env.version }}_linux_arm64.tar.gz   apps/m7s-website/src/public/bin/m7s_linux_arm64.tar.gz 
+    #     ls apps/m7s-website/src/public/bin
+    - name: copy
+      if: success() && startsWith(github.ref, 'refs/tags/')
+      run:  |
+        mkdir -p bin
+        cp dist/m7s_${{ env.version }}_windows_amd64.tar.gz bin/m7s_v5_windows_amd64.tar.gz
+        cp dist/m7s_${{ env.version }}_darwin_amd64.tar.gz  bin/m7s_v5_darwin_amd64.tar.gz 
+        cp dist/m7s_${{ env.version }}_darwin_arm64.tar.gz  bin/m7s_v5_darwin_arm64.tar.gz 
+        cp dist/m7s_${{ env.version }}_linux_amd64.tar.gz   bin/m7s_v5_linux_amd64.tar.gz 
+        cp dist/m7s_${{ env.version }}_linux_arm64.tar.gz   bin/m7s_v5_linux_arm64.tar.gz 
+        ls bin
+    - uses: jakejarvis/s3-sync-action@master
+        # with:
+        #   args: --acl public-read --follow-symlinks --delete
+      env:
+        AWS_S3_ENDPOINT: https://${{ secrets.R2_DOMAIN }}
+        AWS_ACCESS_KEY_ID: ${{ secrets.R2_KEY }}
+        AWS_SECRET_ACCESS_KEY: ${{ secrets.R2_SECRET }}
+        AWS_S3_BUCKET: monibuca
+        SOURCE_DIR: 'bin'
+        DEST_DIR: ${{ env.dest }}
+    - name: Set up QEMU
+      uses: docker/setup-qemu-action@v3
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+    - name: docker build
+      if: success() && startsWith(github.ref, 'refs/tags/')
+      run:  |
+        curl -L https://download.m7s.live/bin/admin.zip -o admin.zip
+        tar -zxvf bin/m7s_v5_linux_amd64.tar.gz
+        mv m7s monibuca_amd64
+        tar -zxvf bin/m7s_v5_linux_arm64.tar.gz
+        mv m7s monibuca_arm64
+        docker login -u langhuihui -p ${{ secrets.DOCKER_PASSWORD }}
+        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:  |
+        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

.gitignore

@@ -12,4 +12,16 @@ bin
 !plugin/record
 *.flv
 pullcf.yaml
-admin.zip
+*.zip
+*.mp4
+!plugin/hls/hls.js.zip
+__debug*
+.cursorrules
+example/default/*
+!example/default/main.go
+!example/default/config.yaml
+!example/default/test.flv
+!example/default/test.mp4
+shutdown.sh
+!example/test/test.db
+shutdown.bat

CLAUDE.md

@@ -0,0 +1,369 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Monibuca is a high-performance streaming server framework written in Go. It's designed to be a modular, scalable platform for real-time audio/video streaming with support for multiple protocols including RTMP, RTSP, HLS, WebRTC, GB28181, and more.
+
+## Development Commands
+
+### Building and Running
+
+**Basic Run (with SQLite):**
+```bash
+cd example/default
+go run -tags sqlite main.go
+```
+
+**Build Tags:**
+- `sqlite` - Enable SQLite database support
+- `sqliteCGO` - Enable SQLite with CGO
+- `mysql` - Enable MySQL database support  
+- `postgres` - Enable PostgreSQL database support
+- `duckdb` - Enable DuckDB database support
+- `disable_rm` - Disable memory pool
+- `fasthttp` - Use fasthttp instead of net/http
+- `taskpanic` - Enable panics for testing
+
+**Protocol Buffer Generation:**
+```bash
+# Generate all proto files
+sh scripts/protoc.sh
+
+# Generate specific plugin proto
+sh scripts/protoc.sh plugin_name
+```
+
+**Release Building:**
+```bash
+# Uses goreleaser configuration
+goreleaser build
+```
+
+**Testing:**
+```bash
+go test ./...
+```
+
+## Architecture Overview
+
+### Core Components
+
+**Server (`server.go`):** Main server instance that manages plugins, streams, and configurations. Implements the central event loop and lifecycle management.
+
+**Plugin System (`plugin.go`):** Modular architecture where functionality is provided through plugins. Each plugin implements the `IPlugin` interface and can provide:
+- Protocol handlers (RTMP, RTSP, etc.)
+- Media transformers
+- Pull/Push proxies
+- Recording capabilities
+- Custom HTTP endpoints
+
+**Configuration System (`pkg/config/`):** Hierarchical configuration system with priority order: dynamic modifications > environment variables > config files > default YAML > global config > defaults.
+
+**Task System (`pkg/task/`):** Advanced asynchronous task management system with multiple layers:
+- **Task:** Basic unit of work with lifecycle management (Start/Run/Dispose)
+- **Job:** Container that manages multiple child tasks and provides event loops
+- **Work:** Special type of Job that acts as a persistent queue manager (keepalive=true)
+- **Channel:** Event-driven task for handling continuous data streams
+
+### Task System Deep Dive
+
+#### Task Hierarchy and Lifecycle
+```
+Work (Queue Manager)
+  └── Job (Container with Event Loop)
+      └── Task (Basic Work Unit)
+          ├── Start() - Initialization phase
+          ├── Run() - Main execution phase
+          └── Dispose() - Cleanup phase
+```
+
+#### Queue-based Asynchronous Processing
+The Task system supports sophisticated queue-based processing patterns:
+
+1. **Work as Queue Manager:** Work instances stay alive indefinitely and manage queues of tasks
+2. **Task Queuing:** Use `workInstance.AddTask(task, logger)` to queue tasks
+3. **Automatic Lifecycle:** Tasks are automatically started, executed, and disposed
+4. **Error Handling:** Built-in retry mechanisms and error propagation
+
+**Example Pattern (from S3 plugin):**
+```go
+type UploadQueueTask struct {
+    task.Work  // Persistent queue manager
+}
+
+type FileUploadTask struct {
+    task.Task  // Individual work item
+    // ... task-specific fields
+}
+
+// Initialize queue manager (typically in init())
+var uploadQueueTask UploadQueueTask
+m7s.Servers.AddTask(&uploadQueueTask)
+
+// Queue individual tasks
+uploadQueueTask.AddTask(&FileUploadTask{...}, logger)
+```
+
+#### Cross-Plugin Task Cooperation
+Tasks can coordinate across different plugins through:
+
+1. **Global Instance Pattern:** Plugins expose global instances for cross-plugin access
+2. **Event-based Triggers:** One plugin triggers tasks in another plugin
+3. **Shared Queue Managers:** Multiple plugins can use the same Work instance
+
+**Example (MP4 → S3 Integration):**
+```go
+// In MP4 plugin: trigger S3 upload after recording completes
+s3plugin.TriggerUpload(filePath, deleteAfter)
+
+// S3 plugin receives trigger and queues upload task
+func TriggerUpload(filePath string, deleteAfter bool) {
+    if s3PluginInstance != nil {
+        s3PluginInstance.QueueUpload(filePath, objectKey, deleteAfter)
+    }
+}
+```
+
+### Key Interfaces
+
+**Publisher:** Handles incoming media streams and manages track information
+**Subscriber:** Handles outgoing media streams to clients  
+**Puller:** Pulls streams from external sources
+**Pusher:** Pushes streams to external destinations
+**Transformer:** Processes/transcodes media streams
+**Recorder:** Records streams to storage
+
+### Stream Processing Flow
+
+1. **Publisher** receives media data and creates tracks
+2. **Tracks** handle audio/video data with specific codecs
+3. **Subscribers** attach to publishers to receive media
+4. **Transformers** can process streams between publishers and subscribers
+5. **Plugins** provide protocol-specific implementations
+
+### Post-Recording Workflow
+
+Monibuca implements a sophisticated post-recording processing pipeline:
+
+1. **Recording Completion:** MP4 recorder finishes writing stream data
+2. **Trailer Writing:** Asynchronous task moves MOOV box to file beginning for web compatibility
+3. **File Optimization:** Temporary file operations ensure atomic updates
+4. **External Storage Integration:** Automatic upload to S3-compatible services
+5. **Cleanup:** Optional local file deletion after successful upload
+
+This workflow uses queue-based task processing to avoid blocking the main recording pipeline.
+
+## Plugin Development
+
+### Creating a Plugin
+
+1. Implement the `IPlugin` interface
+2. Define plugin metadata using `PluginMeta`
+3. Register with `InstallPlugin[YourPluginType](meta)`
+4. Optionally implement protocol-specific interfaces:
+   - `ITCPPlugin` for TCP servers
+   - `IUDPPlugin` for UDP servers  
+   - `IQUICPlugin` for QUIC servers
+   - `IRegisterHandler` for HTTP endpoints
+
+### Plugin Lifecycle
+
+1. **Init:** Configuration parsing and initialization
+2. **Start:** Network listeners and task registration
+3. **Run:** Active operation
+4. **Dispose:** Cleanup and shutdown
+
+### Cross-Plugin Communication Patterns
+
+#### 1. Global Instance Pattern
+```go
+// Expose global instance for cross-plugin access
+var s3PluginInstance *S3Plugin
+
+func (p *S3Plugin) Start() error {
+    s3PluginInstance = p  // Set global instance
+    // ... rest of start logic
+}
+
+// Provide public API functions
+func TriggerUpload(filePath string, deleteAfter bool) {
+    if s3PluginInstance != nil {
+        s3PluginInstance.QueueUpload(filePath, objectKey, deleteAfter)
+    }
+}
+```
+
+#### 2. Event-Driven Integration
+```go
+// In one plugin: trigger event after completion
+if t.filePath != "" {
+    t.Info("MP4 file processing completed, triggering S3 upload")
+    s3plugin.TriggerUpload(t.filePath, false)
+}
+```
+
+#### 3. Shared Queue Managers
+Multiple plugins can share Work instances for coordinated processing.
+
+### Asynchronous Task Development Best Practices
+
+#### 1. Implement Task Interfaces
+```go
+type MyTask struct {
+    task.Task
+    // ... custom fields
+}
+
+func (t *MyTask) Start() error {
+    // Initialize resources, validate inputs
+    return nil
+}
+
+func (t *MyTask) Run() error {
+    // Main work execution
+    // Return task.ErrTaskComplete for successful completion
+    return nil
+}
+```
+
+#### 2. Use Work for Queue Management
+```go
+type MyQueueManager struct {
+    task.Work
+}
+
+var myQueue MyQueueManager
+
+func init() {
+    m7s.Servers.AddTask(&myQueue)
+}
+
+// Queue tasks from anywhere
+myQueue.AddTask(&MyTask{...}, logger)
+```
+
+#### 3. Error Handling and Retry
+- Tasks automatically support retry mechanisms
+- Use `task.SetRetry(maxRetry, interval)` for custom retry behavior
+- Return `task.ErrTaskComplete` for successful completion
+- Return other errors to trigger retry or failure handling
+
+## Configuration Structure
+
+### Global Configuration
+- HTTP/TCP/UDP/QUIC listeners
+- Database connections (SQLite, MySQL, PostgreSQL, DuckDB)
+- Authentication settings
+- Admin interface settings
+- Global stream alias mappings
+
+### Plugin Configuration
+Each plugin can define its own configuration structure that gets merged with global settings.
+
+## Database Integration
+
+Supports multiple database backends:
+- **SQLite:** Default lightweight option
+- **MySQL:** Production deployments
+- **PostgreSQL:** Production deployments  
+- **DuckDB:** Analytics use cases
+
+Automatic migration is handled for core models including users, proxies, and stream aliases.
+
+## Protocol Support
+
+### Built-in Plugins
+- **RTMP:** Real-time messaging protocol
+- **RTSP:** Real-time streaming protocol
+- **HLS:** HTTP live streaming
+- **WebRTC:** Web real-time communication
+- **GB28181:** Chinese surveillance standard
+- **FLV:** Flash video format
+- **MP4:** MPEG-4 format with post-processing capabilities
+- **SRT:** Secure reliable transport
+- **S3:** File upload integration with AWS S3/MinIO compatibility
+
+## Authentication & Security
+
+- JWT-based authentication for admin interface
+- Stream-level authentication with URL signing
+- Role-based access control (admin/user)
+- Webhook support for external auth integration
+
+## Development Guidelines
+
+### Code Style
+- Follow existing patterns and naming conventions
+- Use the task system for async operations
+- Implement proper error handling and logging
+- Use the configuration system for all settings
+
+### Testing
+- Unit tests should be placed alongside source files
+- Integration tests can use the example configurations
+- Use the mock.py script for protocol testing
+
+### Async Task Development
+- Always use Work instances for queue management
+- Implement proper Start/Run lifecycle in tasks
+- Use global instance pattern for cross-plugin communication
+- Handle errors gracefully with appropriate retry strategies
+
+### Performance Considerations
+- Memory pool is enabled by default (disable with `disable_rm`)
+- Zero-copy design for media data where possible
+- Lock-free data structures for high concurrency
+- Efficient buffer management with ring buffers
+- Queue-based processing prevents blocking main threads
+
+## Debugging
+
+### Built-in Debug Plugin
+- Performance monitoring and profiling
+- Real-time metrics via Prometheus endpoint (`/api/metrics`)
+- pprof integration for memory/cpu profiling
+
+### Logging
+- Structured logging with zerolog
+- Configurable log levels
+- Log rotation support
+- Fatal crash logging
+
+### Task System Debugging
+- Tasks automatically include detailed logging with task IDs and types
+- Use `task.Debug/Info/Warn/Error` methods for consistent logging
+- Task state and progress can be monitored through descriptions
+- Event loop status and queue lengths are logged automatically
+
+## Web Admin Interface
+
+- Web-based admin UI served from `admin.zip`
+- RESTful API for all operations
+- Real-time stream monitoring
+- Configuration management
+- User management (when auth enabled)
+
+## Common Issues
+
+### Port Conflicts
+- Default HTTP port: 8080
+- Default gRPC port: 50051
+- Check plugin-specific port configurations
+
+### Database Connection
+- Ensure proper build tags for database support
+- Check DSN configuration strings
+- Verify database file permissions
+
+### Plugin Loading
+- Plugins are auto-discovered from imports
+- Check plugin enable/disable status
+- Verify configuration merging
+
+### Task System Issues
+- Ensure Work instances are added to server during initialization
+- Check task queue status if tasks aren't executing
+- Verify proper error handling in task implementation
+- Monitor task retry counts and failure reasons in logs

Dockerfile

@@ -1,34 +1,36 @@
-# Compile Stage 
-FROM golang:1.23.2-bullseye AS builder
-
-
-LABEL stage=gobuilder
-
-# Env 
-ENV CGO_ENABLED 0
-ENV GOOS linux 
-ENV GOARCH amd64
-#ENV GOPROXY https://goproxy.cn,direct
-ENV HOME /monibuca 
-
-WORKDIR /
-
-RUN git clone -b v5 --depth 1 https://github.com/langhuihui/monibuca
-
-# compile 
-WORKDIR /monibuca
-RUN go build -tags sqlite -o ./build/monibuca ./example/default/main.go
-
-RUN cp -r /monibuca/example/default/config.yaml /monibuca/build
-
 # Running Stage 
-FROM alpine:3.20
+FROM linuxserver/ffmpeg:latest
 
 WORKDIR /monibuca 
-COPY --from=builder /monibuca/build /monibuca/
-RUN cp -r ./config.yaml /etc/monibuca
-# Export necessary ports 
-EXPOSE 8080 8443 1935 554 5060 9000-20000
-EXPOSE 5060/udp
 
-CMD [ "./monibuca", "-c", "/etc/monibuca/config.yaml" ]
+# 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 example/default/test.mp4 ./test.mp4
+COPY example/default/test.flv ./test.flv
+
+# Install tcpdump
+RUN apt-get update && apt-get install -y tcpdump && rm -rf /var/lib/apt/lists/*
+
+# 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"]

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"]

GEMINI.md

@@ -0,0 +1,92 @@
+# Gemini Context: Monibuca Project
+
+This document provides a summary of the Monibuca project to give context for AI-assisted development.
+
+## Project Overview
+
+Monibuca is a modular, high-performance streaming media server framework written in Go. Its core design is lightweight and plugin-based, allowing developers to extend functionality by adding or developing plugins for different streaming protocols and features. The project's module path is `m7s.live/v4`.
+
+The architecture is centered around a core engine (`m7s.live/v4`) that manages plugins, streams, and the main event loop. Functionality is added by importing plugins, which register themselves with the core engine.
+
+**Key Technologies:**
+- **Language:** Go
+- **Architecture:** Plugin-based
+- **APIs:** RESTful HTTP API, gRPC API
+
+**Supported Protocols (based on plugins):**
+- RTMP
+- RTSP
+- HLS
+- FLV
+- WebRTC
+- GB28181
+- SRT
+- And more...
+
+## Building and Running
+
+### Build
+To build the server, run the following command from the project root:
+```bash
+go build -v .
+```
+
+### Test
+To run the test suite:
+```bash
+go test -v ./...
+```
+
+### Running the Server
+The server is typically run by creating a `main.go` file that imports the core engine and the desired plugins.
+
+**Example `main.go`:**
+```go
+package main
+
+import (
+	"m7s.live/v4"
+	// Import desired plugins to register them
+	_ "m7s.live/plugin/rtmp/v4"
+	_ "m7s.live/plugin/rtsp/v4"
+	_ "m7s.live/plugin/hls/v4"
+	_ "m7s.live/plugin/webrtc/v4"
+)
+
+func main() {
+	m7s.Run()
+}
+```
+The server is executed by running `go run main.go`. Configuration is managed through a `config.yaml` file in the same directory.
+
+### Docker
+The project includes a `Dockerfile` to build and run in a container.
+```bash
+# Build the image
+docker build -t monibuca .
+
+# Run the container
+docker run -p 8080:8080 monibuca
+```
+
+## Development Conventions
+
+### Project Structure
+- `server.go`: Core engine logic.
+- `plugin/`: Contains individual plugins for different protocols and features.
+- `pkg/`: Shared packages and utilities used across the project.
+- `pb/`: Protobuf definitions for the gRPC API.
+- `example/`: Example implementations and configurations.
+- `doc/`: Project documentation.
+
+### Plugin System
+The primary way to add functionality is by creating or enabling plugins. A plugin is a Go package that registers itself with the core engine upon import (using the `init()` function). This modular approach keeps the core small and allows for custom builds with only the necessary features.
+
+### API
+- **RESTful API:** Defined in `api.go`, provides HTTP endpoints for controlling and monitoring the server.
+- **gRPC API:** Defined in the `pb/` directory using protobuf. `protoc.sh` is used to generate the Go code from the `.proto` files.
+
+### Code Style and CI
+- The project uses `golangci-lint` for linting, as seen in the `.github/workflows/go.yml` file.
+- Static analysis is configured via `staticcheck.conf` and `qodana.yaml`.
+- All code should be formatted with `gofmt`.

IFLOW.md

@@ -0,0 +1,124 @@
+# Monibuca v5 项目概述
+
+Monibuca 是一个使用纯 Go 语言开发的、高度可扩展的高性能流媒体服务器开发框架。它旨在提供高并发、低延迟的流媒体处理能力，并支持多种流媒体协议和功能。
+
+## 核心特性
+
+*   **高性能**: 采用无锁设计、部分手动内存管理和多核计算。
+*   **低延迟**: 实现零等待转发，全链路亚秒级延迟。
+*   **模块化**: 按需加载，无限扩展性。
+*   **灵活性**: 高度可配置，适应各种流媒体场景。
+*   **可扩展性**: 支持分布式部署，轻松应对大规模场景。
+*   **调试友好**: 内置调试插件，实时性能监控与分析。
+*   **媒体处理**: 支持截图、转码、SEI 数据处理。
+*   **集群能力**: 内置级联和房间管理。
+*   **预览功能**: 支持视频预览、多屏预览、自定义屏幕布局。
+*   **安全性**: 提供加密传输和流认证。
+*   **性能监控**: 支持压力测试和性能指标收集（集成在测试插件中）。
+*   **日志管理**: 日志轮转、自动清理、自定义扩展。
+*   **录制与回放**: 支持 MP4、HLS、FLV 格式，支持倍速、寻址、暂停。
+*   **动态时移**: 动态缓存设计，支持直播时移回放。
+*   **远程调用**: 支持 gRPC 接口，实现跨语言集成。
+*   **流别名**: 支持动态流别名，灵活的多流管理。
+*   **AI 能力**: 集成推理引擎，支持 ONNX 模型，支持自定义前后处理。
+*   **WebHook**: 订阅流生命周期事件，用于业务系统集成。
+*   **私有协议**: 支持自定义私有协议以满足特殊业务需求。
+
+## 支持的协议
+
+*   RTMP
+*   RTSP
+*   HTTP-FLV
+*   WS-FLV
+*   HLS
+*   WebRTC
+*   GB28181
+*   ONVIF
+*   SRT
+
+## 技术架构
+
+Monibuca 基于插件化架构设计，核心功能通过插件扩展。主要组件包括：
+
+*   **Server**: 核心服务器，负责管理流、插件、任务等。
+*   **Plugin**: 插件系统，提供各种功能扩展。
+*   **Publisher**: 流发布者，负责接收和管理流数据。
+*   **Subscriber**: 流订阅者，负责消费流数据。
+*   **Task**: 任务系统，用于管理异步任务和生命周期。
+*   **Config**: 配置系统，支持多层级配置（环境变量、配置文件、默认值等）。
+
+## 构建与运行
+
+### 前提条件
+
+*   Go 1.23 或更高版本
+*   对流媒体协议有基本了解
+
+### 运行默认配置
+
+```bash
+cd example/default
+go run -tags sqlite main.go
+```
+
+### 构建标签
+
+可以使用以下构建标签来自定义构建：
+
+| 构建标签 | 描述 |
+| :--- | :--- |
+| `disable_rm` | 禁用内存池 |
+| `sqlite` | 启用 sqlite DB |
+| `sqliteCGO` | 启用 sqlite cgo 版本 DB |
+| `mysql` | 启用 mysql DB |
+| `postgres` | 启用 postgres DB |
+| `duckdb` | 启用 duckdb DB |
+| `taskpanic` | 抛出 panic，用于测试 |
+| `fasthttp` | 启用 fasthttp 服务器而不是 net/http |
+
+### Web UI
+
+将 `admin.zip` 文件（不要解压）放在与配置文件相同的目录中。然后访问 http://localhost:8080 即可访问 UI。
+
+## 开发约定
+
+### 项目结构
+
+*   `example/`: 包含各种使用示例。
+*   `pkg/`: 核心库代码。
+*   `plugin/`: 各种功能插件。
+*   `pb/`: Protocol Buffer 生成的代码。
+*   `doc/`: 项目文档。
+*   `scripts/`: 脚本文件。
+
+### 配置
+
+*   使用 YAML 格式进行配置。
+*   支持多层级配置覆盖（环境变量 > 配置文件 > 默认值）。
+*   插件配置通常以插件名小写作为前缀。
+
+### 日志
+
+*   使用 `slog` 进行日志记录。
+*   支持不同日志级别（debug, info, warn, error, trace）。
+*   插件可以有自己的日志记录器。
+
+### 插件开发
+
+*   插件需要实现 `IPlugin` 接口。
+*   通过 `InstallPlugin` 函数注册插件。
+*   插件可以注册 HTTP 处理函数、gRPC 服务等。
+*   插件可以有自己的配置结构体。
+
+### 任务系统
+
+*   使用 `task` 包管理异步任务。
+*   任务具有生命周期管理（启动、停止、销毁）。
+*   任务可以有父子关系，形成任务树。
+*   支持任务重试机制。
+
+### 测试
+
+*   使用 Go 标准测试包 `testing`。
+*   在 `test/` 目录下编写集成测试。
+*   使用 `example/test` 目录进行功能测试。

README.md

@@ -1,26 +1,111 @@
+<!-- Improved compatibility of back to top link -->
+<a id="readme-top"></a>
 
-# Introduction
-Monibuca is a highly scalable high-performance streaming server development framework developed purely for Go
-# Usage
+[![Contributors][contributors-shield]][contributors-url]
+[![Forks][forks-shield]][forks-url]
+[![Stargazers][stars-shield]][stars-url]
+[![Issues][issues-shield]][issues-url]
+[![MIT License][license-shield]][license-url]
 
-```go
-package main
+<!-- PROJECT LOGO -->
+<br />
+<div align="center">
+<a href="https://m7s.live">
+    <img src="https://m7s.live/logo+.svg" alt="Logo" width="200">
+  </a>
+  <h1 align="center">Monibuca v5</h1>
 
-import (
-	"context"
+  <p align="center">
+    A highly scalable high-performance streaming server development framework developed purely in Go
+    <br />
+    <a href="./README_CN.md">中文文档</a>
+    ·
+    <a href="https://github.com/Monibuca/v5/wiki"><strong>Explore the docs »</strong></a>
+    <br />
+    <br />
+    <a href="https://github.com/Monibuca/v5/issues">Report Bug</a>
+    ·
+    <a href="https://github.com/Monibuca/v5/issues">Request Feature</a>
+  </p>
+</div>
 
-	"m7s.live/v5"
-	_ "m7s.live/v5/plugin/debug"
-	_ "m7s.live/v5/plugin/flv"
-	_ "m7s.live/v5/plugin/rtmp"
-)
+<!-- TABLE OF CONTENTS -->
+<details>
+  <summary>Table of Contents</summary>
+  <ol>
+    <li><a href="#about">About</a></li>
+    <li><a href="#getting-started">Getting Started</a></li>
+    <li><a href="#usage">Usage</a></li>
+    <li><a href="#build-tags">Build Tags</a></li>
+    <li><a href="#monitoring">Monitoring</a></li>
+    <li><a href="#plugin-development">Plugin Development</a></li>
+    <li><a href="#arch">Architecture</a></li>
+    <li><a href="#third-party-plugins">Third-party Plugins</a></li>
+    <li><a href="#contributing">Contributing</a></li>
+    <li><a href="#license">License</a></li>
+    <li><a href="#contact">Contact</a></li>
+  </ol>
+</details>
 
-func main() {
-	m7s.Run(context.Background(), "config.yaml")
-}
+## About
 
+Monibuca is a powerful streaming server framework written entirely in Go. It's designed to be:
+
+- 🚀 **High Performance** - Lock-free design, partial manual memory management, multi-core computing
+- ⚡ **Low Latency** - Zero-wait forwarding, sub-second latency across the entire chain
+- 📦 **Modular** - Load on demand, unlimited extensibility
+- 🔧 **Flexible** - Highly configurable to meet various streaming scenarios
+- 💪 **Scalable** - Supports distributed deployment, easily handles large-scale scenarios
+- 🔍 **Debug Friendly** - Built-in debug plugin, real-time performance monitoring and analysis
+- 🎥 **Media Processing** - Supports screenshot, transcoding, SEI data processing
+- 🔄 **Cluster Capability** - Built-in cascade and room management
+- 🎮 **Preview Features** - Supports video preview, multi-screen preview, custom screen layouts
+- 🔐 **Security** - Provides encrypted transmission and stream authentication
+- 📊 **Performance Monitoring** - Supports stress testing and performance metrics collection (integrated in test plugin)
+- 📝 **Log Management** - Log rotation, auto cleanup, custom extensions
+- 🎬 **Recording & Playback** - Supports MP4, HLS, FLV formats, speed control, seeking, pause
+- ⏱️ **Dynamic Time-Shift** - Dynamic cache design, supports live time-shift playback
+- 🌐 **Remote Call** - Supports gRPC interface for cross-language integration
+- 🏷️ **Stream Alias** - Supports dynamic stream alias, flexible multi-stream management
+- 🤖 **AI Capabilities** - Integrated inference engine, ONNX model support, custom pre/post processing
+- 🪝 **WebHook** - Subscribe to stream lifecycle events for business system integration
+- 🔒 **Private Protocol** - Supports custom private protocols for special business needs
+
+- 🔄 **Supported Protocols**: RTMP, RTSP, HTTP-FLV, WS-FLV, HLS, WebRTC, GB28181, ONVIF, SRT
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
+
+## Getting Started
+
+### Prerequisites
+
+- Go 1.23 or higher
+- Basic understanding of streaming protocols
+
+### Run with Default Configuration
+
+```bash
+cd example/default
+go run -tags sqlite main.go
 ```
-## build tags
+
+### Web UI
+
+Place the `admin.zip` file (do not unzip) in the same directory as your configuration file.
+
+Then visit http://localhost:8080 to access the UI.
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
+
+## Examples
+
+For more examples, please check out the [example](./example) documentation.
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
+
+## Build Tags
+
+The following build tags can be used to customize your build:
 
 | Build Tag | Description |
 |-----------|-------------|
@@ -31,12 +116,14 @@ func main() {
 | postgres | Enables the postgres DB |
 | duckdb | Enables the duckdb DB |
 | taskpanic | Throws panic, for testing |
+| fasthttp | Enables the fasthttp server instead of net/http |
+| enable_buddy | Enables the buddy memory pre-allocation |
 
-## More Example
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
 
-see example directory
+## Monitoring
 
-# Prometheus
+Monibuca supports Prometheus monitoring out of the box. Add the following to your Prometheus configuration:
 
 ```yaml
 scrape_configs:
@@ -46,6 +133,62 @@ scrape_configs:
       - targets: ["localhost:8080"]
 ```
 
-# Create Plugin
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
 
-see [plugin](./plugin/README.md)
+## Plugin Development
+
+Monibuca's functionality can be extended through plugins. For information on creating plugins, see the [plugin guide](./plugin/README.md).
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
+
+## Architecture
+
+For detailed architecture design documentation, please refer to the [Architecture Documentation](./doc/arch/index.md).
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
+
+## Third-party Plugins
+
+- https://github.com/cuteLittleDevil/m7s-jt1078
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
+
+## Contributing
+
+Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.
+
+1. Fork the Project
+2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
+4. Push to the Branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
+
+## License
+
+Distributed under the AGPL License. See `LICENSE` for more information.
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
+
+<!-- CONTACT -->
+## Contact
+
+monibuca - [@m7server](https://x.com/m7server) - service@monibuca.com
+
+Project Link: [https://github.com/langhuihui/monibuca](https://github.com/langhuihui/monibuca)
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
+
+
+<!-- MARKDOWN LINKS & IMAGES -->
+[contributors-shield]: https://img.shields.io/github/contributors/langhuihui/monibuca.svg?style=for-the-badge
+[contributors-url]: https://github.com/langhuihui/monibuca/graphs/contributors
+[forks-shield]: https://img.shields.io/github/forks/langhuihui/monibuca.svg?style=for-the-badge
+[forks-url]: https://github.com/langhuihui/monibuca/network/members
+[stars-shield]: https://img.shields.io/github/stars/langhuihui/monibuca.svg?style=for-the-badge
+[stars-url]: https://github.com/langhuihui/monibuca/stargazers
+[issues-shield]: https://img.shields.io/github/issues/langhuihui/monibuca.svg?style=for-the-badge
+[issues-url]: https://github.com/langhuihui/monibuca/issues
+[license-shield]: https://img.shields.io/github/license/langhuihui/monibuca.svg?style=for-the-badge
+[license-url]: https://github.com/langhuihui/monibuca/blob/v5/LICENSE

README_CN.md

@@ -1,45 +1,128 @@
-# 介绍
-monibuca 是一款纯 go 开发的扩展性极强的高性能流媒体服务器开发框架
+# Monibuca v5
 
-# 使用
-```go
-package main
-import (
-	"context"
+<a id="readme-top"></a>
 
-	"m7s.live/v5"
-	_ "m7s.live/v5/plugin/debug"
-	_ "m7s.live/v5/plugin/flv"
-	_ "m7s.live/v5/plugin/rtmp"
-)
+[![Contributors][contributors-shield]][contributors-url]
+[![Forks][forks-shield]][forks-url]
+[![Stargazers][stars-shield]][stars-url]
+[![Issues][issues-shield]][issues-url]
+[![AGPL License][license-shield]][license-url]
+[![Go Reference](https://pkg.go.dev/badge/m7s.live/v5.svg)](https://pkg.go.dev/m7s.live/v5)
+<a href="https://hellogithub.com/repository/6d7916d851c2481f87568ffd9f1c21d9" target="_blank"><img src="https://api.hellogithub.com/v1/widgets/recommend.svg?rid=6d7916d851c2481f87568ffd9f1c21d9&claim_uid=riBYPOGenUf7kbc&theme=small" alt="Featured｜HelloGitHub" /></a>
+<br />
+<div align="center">
+  <a href="https://monibuca.com">
+    <img src="https://monibuca.com/logo+.svg" alt="Logo" width="200">
+  </a>
 
-func main() {
-	m7s.Run(context.Background(), "config.yaml")
-}
+  <h1 align="center">Monibuca v5</h1>
+  <p align="center">
+    强大的纯 Go 开发的流媒体服务器开发框架
+    <br />
+    <a href="https://monibuca.com"><strong>官方网站 »</strong></a>
+    <br />
+    <br />
+    <a href="https://github.com/langhuihui/monibuca/issues">报告问题</a>
+    ·
+    <a href="https://github.com/langhuihui/monibuca/issues">功能建议</a>
+  </p>
+</div>
 
+<!-- 目录 -->
+<details>
+  <summary>目录</summary>
+  <ol>
+    <li><a href="#项目介绍">项目介绍</a></li>
+    <li><a href="#快速开始">快速开始</a></li>
+    <li><a href="#使用示例">使用示例</a></li>
+    <li><a href="#构建选项">构建选项</a></li>
+    <li><a href="#监控系统">监控系统</a></li>
+    <li><a href="#插件开发">插件开发</a></li>
+    <li><a href="#架构文档">架构文档</a></li>
+    <li><a href="#贡献指南">贡献指南</a></li>
+    <li><a href="#许可证">许可证</a></li>
+    <li><a href="#联系方式">联系方式</a></li>
+  </ol>
+</details>
+
+## 项目介绍
+
+Monibuca（简称 m7s）是一款纯 Go 开发的开源流媒体服务器开发框架。它具有以下特点：
+
+- 🚀 **高性能** - 无锁设计、部分手动管理内存、多核计算
+- ⚡ **低延迟** - 0 等待转发、全链路亚秒级延迟
+- 📦 **插件化** - 按需加载，无限扩展能力
+- 🔧 **灵活性** - 高度可配置，满足各种流媒体场景需求
+- 💪 **可扩展** - 支持分布式部署，轻松应对大规模场景
+- 🔍 **调试友好** - 内置调试插件，支持实时性能监控和分析
+- 🎥 **媒体处理** - 支持截图、转码、SEI 数据处理
+- 🔄 **集群能力** - 内置级联和房间管理功能
+- 🎮 **预览功能** - 支持视频预览、分屏预览、自定义分屏
+- 🔐 **安全加密** - 提供加密传输和流鉴权能力
+- 📊 **性能监控** - 支持压力测试和性能指标采集
+- 📝 **日志管理** - 日志轮转、自动清理、自定义扩展
+- 🎬 **录制回放** - 支持 MP4、HLS、FLV 格式录制、倍速播放、拖拽快进、暂停能力
+- ⏱️ **动态时移** - 动态缓存设计，支持直播时移回看
+- 🌐 **远程调用** - 支持 gRPC 接口，方便跨语言集成
+- 🏷️ **流别名** - 支持动态设置流别名，灵活管理多路流，实现导播功能
+- 🤖 **AI 能力** - 集成推理引擎，支持 ONNX 模型，支持自定义的前置处理，后置处理，以及画框
+- 🪝 **WebHook** - 支持订阅流的生命周期事件，实现业务系统联动
+- 🔒 **私有协议** - 支持自定义私有协议，满足特殊业务需求
+
+- 🔄 **多协议支持**：RTMP、RTSP、HTTP-FLV、WS-FLV、HLS、WebRTC、GB28181、ONVIF、SRT
+
+<p align="right">(<a href="#readme-top">返回顶部</a>)</p>
+
+
+## 快速开始
+
+### 环境要求
+
+- Go 1.23 或更高版本
+- 了解基本的流媒体协议
+
+### 运行默认配置
+
+```bash
+cd example/default
+go run -tags sqlite main.go
 ```
-## 构建标签
+### UI 界面
 
-| 标签 | 描述              |
-|-----------|-----------------|
-| disable_rm | 禁用内存池           |
-| sqlite | 启用 sqlite       |
-| sqliteCGO | 启用 sqlite cgo版本 |
-| mysql | 启用 mysql       |
-| postgres | 启用 postgres       |
-| duckdb | 启用 duckdb       |
-| taskpanic | 抛出 panic，用于测试   |
+将 admin.zip （不要解压）放在和配置文件相同目录下。
+
+然后访问 http://localhost:8080 即可。
 
 
-## 更多示例
+<p align="right">(<a href="#readme-top">返回顶部</a>)</p>
 
-查看 example 目录
+## 使用示例
 
-# 创建插件
+更多示例请查看 [example](./example/READEME_CN.md) 文档。
 
-到 plugin 目录下查看 README_CN.md
+<p align="right">(<a href="#readme-top">返回顶部</a>)</p>
 
-# Prometheus
+## 构建选项
+
+可以使用以下构建标签来自定义构建：
+
+| 构建标签 | 描述 |
+|----------|------|
+| disable_rm | 禁用内存池 |
+| sqlite | 启用 SQLite 存储 |
+| sqliteCGO | 启用 SQLite CGO 版本 |
+| mysql | 启用 MySQL 存储 |
+| postgres | 启用 PostgreSQL 存储 |
+| duckdb | 启用 DuckDB 存储 |
+| taskpanic | 抛出 panic（用于测试） |
+| fasthttp | 使用 fasthttp 服务器代替标准库 |
+| enable_buddy | 开启 buddy 内存预申请|
+
+<p align="right">(<a href="#readme-top">返回顶部</a>)</p>
+
+## 监控系统
+
+Monibuca 内置支持 Prometheus 监控。在 Prometheus 配置中添加：
 
 ```yaml
 scrape_configs:
@@ -48,3 +131,59 @@ scrape_configs:
     static_configs:
       - targets: ["localhost:8080"]
 ```
+
+<p align="right">(<a href="#readme-top">返回顶部</a>)</p>
+
+## 插件开发
+
+Monibuca 支持通过插件扩展功能。查看[插件开发指南](./plugin/README_CN.md)了解详情。
+
+<p align="right">(<a href="#readme-top">返回顶部</a>)</p>
+
+## 架构文档
+
+详细的架构设计文档请查看 [架构文档](./doc_CN/arch/index.md)。
+
+<p align="right">(<a href="#readme-top">返回顶部</a>)</p>
+
+## 第三方插件
+
+- - https://github.com/cuteLittleDevil/m7s-jt1078
+
+## 贡献指南
+
+我们非常欢迎社区贡献，您的参与将使开源社区变得更加精彩！
+
+1. Fork 本项目
+2. 创建您的特性分支 (`git checkout -b feature/AmazingFeature`)
+3. 提交您的修改 (`git commit -m '添加一些特性'`)
+4. 推送到分支 (`git push origin feature/AmazingFeature`)
+5. 发起 Pull Request
+
+<p align="right">(<a href="#readme-top">返回顶部</a>)</p>
+
+## 许可证
+
+本项目采用 AGPL 许可证，详见 [LICENSE](./LICENSE) 文件。
+
+<p align="right">(<a href="#readme-top">返回顶部</a>)</p>
+
+## 联系方式
+
+- 微信公众号：不卡科技
+- QQ群：751639168
+- QQ频道：p0qq0crz08
+
+<p align="right">(<a href="#readme-top">返回顶部</a>)</p>
+
+<!-- MARKDOWN LINKS & IMAGES -->
+[contributors-shield]: https://img.shields.io/github/contributors/langhuihui/monibuca.svg?style=for-the-badge
+[contributors-url]: https://github.com/langhuihui/monibuca/graphs/contributors
+[forks-shield]: https://img.shields.io/github/forks/langhuihui/monibuca.svg?style=for-the-badge
+[forks-url]: https://github.com/langhuihui/monibuca/network/members
+[stars-shield]: https://img.shields.io/github/stars/langhuihui/monibuca.svg?style=for-the-badge
+[stars-url]: https://github.com/langhuihui/monibuca/stargazers
+[issues-shield]: https://img.shields.io/github/issues/langhuihui/monibuca.svg?style=for-the-badge
+[issues-url]: https://github.com/langhuihui/monibuca/issues
+[license-shield]: https://img.shields.io/github/license/langhuihui/monibuca.svg?style=for-the-badge
+[license-url]: https://github.com/langhuihui/monibuca/blob/v5/LICENSE

RELEASE_NOTES_5.0.x_CN.md

@@ -0,0 +1,151 @@
+# Monibuca v5.0.x Release Notes
+
+## v5.0.4 (2025-08-15)
+
+### 新增 / 改进 (Features & Improvements)
+- GB28181: 支持更新 channelName / channelId（eba62c4）
+- 定时任务(crontab): 初始化 SQL 支持（2bbee90）
+- Snap 插件: 支持批量抓图（272def3）
+- 管理后台: 支持自定义首页（15d830f）
+- 推/拉代理: 支持可选参数更新（ad32f6f）
+- 心跳/脉冲: pulse interval 允许为 0（17faf3f）
+- 告警上报: 通过 Hook 发送报警（baf3640）
+- 告警信息上报: 通过 Hook 发送 alarminfo（cad47ae）
+
+## 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
+
+---

alarm.go

@@ -0,0 +1,25 @@
+package m7s
+
+import (
+	"time"
+)
+
+// AlarmInfo 报警信息实体，用于存储到数据库
+type AlarmInfo struct {
+	ID         uint      `gorm:"primaryKey;autoIncrement" json:"id"`           // 主键，自增ID
+	ServerInfo string    `gorm:"type:varchar(255);not null" json:"serverInfo"` // 服务器信息
+	StreamName string    `gorm:"type:varchar(255);index" json:"streamName"`    // 流名称
+	StreamPath string    `gorm:"type:varchar(500)" json:"streamPath"`          // 流的streampath
+	AlarmName  string    `gorm:"type:varchar(255);not null" json:"alarmName"`  // 报警名称
+	AlarmDesc  string    `gorm:"type:varchar(500);not null" json:"alarmDesc"`  // 报警描述
+	AlarmType  int       `gorm:"not null;index" json:"alarmType"`              // 报警类型（对应之前定义的常量）
+	IsSent     bool      `gorm:"default:false" json:"isSent"`                  // 是否已成功发送
+	CreatedAt  time.Time `gorm:"autoCreateTime" json:"createdAt"`              // 创建时间,报警时间
+	UpdatedAt  time.Time `gorm:"autoUpdateTime" json:"updatedAt"`              // 更新时间
+	FilePath   string    `gorm:"type:varchar(255)" json:"filePath"`            // 文件路径
+}
+
+// TableName 指定表名
+func (AlarmInfo) TableName() string {
+	return "alarm_info"
+}

alias.go

@@ -0,0 +1,250 @@
+package m7s
+
+import (
+	"context"
+	"net/url"
+	"strings"
+	"time"
+
+	"google.golang.org/protobuf/types/known/emptypb"
+	"m7s.live/v5/pb"
+)
+
+type AliasStream struct {
+	*Publisher `gorm:"-:all"`
+	AutoRemove bool
+	StreamPath string
+	Alias      string `gorm:"primarykey"`
+}
+
+func (a *AliasStream) GetKey() string {
+	return a.Alias
+}
+
+// StreamAliasDB 用于存储流别名的数据库模型
+type StreamAliasDB struct {
+	AliasStream
+	CreatedAt time.Time `yaml:"-"`
+	UpdatedAt time.Time `yaml:"-"`
+}
+
+func (StreamAliasDB) TableName() string {
+	return "stream_alias"
+}
+
+func (s *Server) initStreamAlias() {
+	if s.DB == nil {
+		return
+	}
+	var aliases []StreamAliasDB
+	s.DB.Find(&aliases)
+	for _, alias := range aliases {
+		s.AliasStreams.Add(&alias.AliasStream)
+		if publisher, ok := s.Streams.Get(alias.StreamPath); ok {
+			alias.Publisher = publisher
+		}
+	}
+}
+
+func (s *Server) GetStreamAlias(ctx context.Context, req *emptypb.Empty) (res *pb.StreamAliasListResponse, err error) {
+	res = &pb.StreamAliasListResponse{}
+	s.CallOnStreamTask(func() {
+		for alias := range s.AliasStreams.Range {
+			info := &pb.StreamAlias{
+				StreamPath: alias.StreamPath,
+				Alias:      alias.Alias,
+				AutoRemove: alias.AutoRemove,
+			}
+			if s.Streams.Has(alias.Alias) {
+				info.Status = 2
+			} else if alias.Publisher != nil {
+				info.Status = 1
+			}
+			res.Data = append(res.Data, info)
+		}
+	})
+	return
+}
+
+func (s *Server) SetStreamAlias(ctx context.Context, req *pb.SetStreamAliasRequest) (res *pb.SuccessResponse, err error) {
+	res = &pb.SuccessResponse{}
+	s.CallOnStreamTask(func() {
+		if req.StreamPath != "" {
+			u, err := url.Parse(req.StreamPath)
+			if err != nil {
+				return
+			}
+			req.StreamPath = strings.TrimPrefix(u.Path, "/")
+			publisher, canReplace := s.Streams.Get(req.StreamPath)
+			if !canReplace {
+				defer s.OnSubscribe(req.StreamPath, u.Query())
+			}
+			if aliasInfo, ok := s.AliasStreams.Get(req.Alias); ok { //modify alias
+				oldStreamPath := aliasInfo.StreamPath
+				aliasInfo.AutoRemove = req.AutoRemove
+				if aliasInfo.StreamPath != req.StreamPath {
+					aliasInfo.StreamPath = req.StreamPath
+					if canReplace {
+						if aliasInfo.Publisher != nil {
+							aliasInfo.TransferSubscribers(publisher) // replace stream
+							aliasInfo.Publisher = publisher
+						} else {
+							aliasInfo.Publisher = publisher
+							s.Waiting.WakeUp(req.Alias, publisher)
+						}
+					}
+				}
+				// 更新数据库中的别名
+				if s.DB != nil {
+					s.DB.Where("alias = ?", req.Alias).Assign(aliasInfo).FirstOrCreate(&StreamAliasDB{
+						AliasStream: *aliasInfo,
+					})
+				}
+				s.Info("modify alias", "alias", req.Alias, "oldStreamPath", oldStreamPath, "streamPath", req.StreamPath, "replace", ok && canReplace)
+			} else { // create alias
+				aliasInfo := AliasStream{
+					AutoRemove: req.AutoRemove,
+					StreamPath: req.StreamPath,
+					Alias:      req.Alias,
+				}
+				var pubId uint32
+				s.AliasStreams.Add(&aliasInfo)
+				aliasStream, ok := s.Streams.Get(aliasInfo.Alias)
+				if canReplace {
+					aliasInfo.Publisher = publisher
+					if ok {
+						aliasStream.TransferSubscribers(publisher) // replace stream
+					} else {
+						s.Waiting.WakeUp(req.Alias, publisher)
+					}
+				} else if ok {
+					aliasInfo.Publisher = aliasStream
+				}
+				if aliasInfo.Publisher != nil {
+					pubId = aliasInfo.Publisher.ID
+				}
+				// 保存到数据库
+				if s.DB != nil {
+					s.DB.Create(&StreamAliasDB{
+						AliasStream: aliasInfo,
+					})
+				}
+				s.Info("add alias", "alias", req.Alias, "streamPath", req.StreamPath, "replace", ok && canReplace, "pub", pubId)
+			}
+		} else {
+			s.Info("remove alias", "alias", req.Alias)
+			if aliasStream, ok := s.AliasStreams.Get(req.Alias); ok {
+				s.AliasStreams.Remove(aliasStream)
+				// 从数据库中删除
+				if s.DB != nil {
+					s.DB.Where("alias = ?", req.Alias).Delete(&StreamAliasDB{})
+				}
+				if aliasStream.Publisher != nil {
+					if publisher, hasTarget := s.Streams.Get(req.Alias); hasTarget { // restore stream
+						aliasStream.TransferSubscribers(publisher)
+					} else {
+						var args url.Values
+						for sub := range aliasStream.Publisher.SubscriberRange {
+							if sub.StreamPath == req.Alias {
+								aliasStream.Publisher.RemoveSubscriber(sub)
+								s.Waiting.Wait(sub)
+								args = sub.Args
+							}
+						}
+						if args != nil {
+							s.OnSubscribe(req.Alias, args)
+						}
+					}
+				}
+			}
+		}
+	})
+	return
+}
+
+func (p *Publisher) processAliasOnStart() {
+	s := p.Plugin.Server
+	for alias := range s.AliasStreams.Range {
+		if alias.StreamPath != p.StreamPath {
+			continue
+		}
+		if alias.Publisher == nil {
+			alias.Publisher = p
+			s.Waiting.WakeUp(alias.Alias, p)
+		} else if alias.Publisher.StreamPath != alias.StreamPath {
+			alias.Publisher.TransferSubscribers(p)
+			alias.Publisher = p
+		}
+	}
+}
+
+func (p *Publisher) processAliasOnDispose() {
+	s := p.Plugin.Server
+	var relatedAlias []*AliasStream
+	for alias := range s.AliasStreams.Range {
+		if alias.StreamPath == p.StreamPath {
+			if alias.AutoRemove {
+				defer s.AliasStreams.Remove(alias)
+				if s.DB != nil {
+					defer s.DB.Where("alias = ?", alias.Alias).Delete(&StreamAliasDB{})
+				}
+			}
+			alias.Publisher = nil
+			relatedAlias = append(relatedAlias, alias)
+		}
+	}
+	if p.Subscribers.Length > 0 {
+	SUBSCRIBER:
+		for subscriber := range p.SubscriberRange {
+			for _, alias := range relatedAlias {
+				if subscriber.StreamPath == alias.Alias {
+					if originStream, ok := s.Streams.Get(alias.Alias); ok {
+						originStream.AddSubscriber(subscriber)
+						continue SUBSCRIBER
+					}
+				}
+			}
+			s.Waiting.Wait(subscriber)
+		}
+		p.Subscribers.Clear()
+	}
+}
+
+func (s *Subscriber) processAliasOnStart() (hasInvited bool, done bool) {
+	server := s.Plugin.Server
+	if alias, ok := server.AliasStreams.Get(s.StreamPath); ok {
+		if alias.Publisher != nil {
+			alias.Publisher.AddSubscriber(s)
+			done = true
+			return
+		} else {
+			server.OnSubscribe(alias.StreamPath, s.Args)
+			hasInvited = true
+		}
+	} else {
+		for reg, alias := range server.StreamAlias {
+			if streamPath := reg.Replace(s.StreamPath, alias); streamPath != "" {
+				as := AliasStream{
+					StreamPath: streamPath,
+					Alias:      s.StreamPath,
+				}
+				server.AliasStreams.Set(&as)
+				if server.DB != nil {
+					server.DB.Where("alias = ?", s.StreamPath).Assign(as).FirstOrCreate(&StreamAliasDB{
+						AliasStream: as,
+					})
+				}
+				if publisher, ok := server.Streams.Get(streamPath); ok {
+					publisher.AddSubscriber(s)
+					done = true
+					return
+				} else {
+					server.OnSubscribe(streamPath, s.Args)
+					hasInvited = true
+				}
+				break
+			}
+		}
+	}
+	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 != "" && !strings.EqualFold(meta.Name, filterName) {
+			continue
+		}
+		name := strings.ToLower(meta.Name)
+		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
+				}{name, mergedConf})
+			} else {
+				configSections = append(configSections, struct {
+					name string
+					data any
+				}{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
+}

device.go

@@ -1,175 +0,0 @@
-package m7s
-
-import (
-	"fmt"
-	"net"
-	"net/url"
-	"strings"
-	"time"
-
-	"gorm.io/gorm"
-	"m7s.live/v5/pkg/config"
-	"m7s.live/v5/pkg/task"
-	"m7s.live/v5/pkg/util"
-)
-
-const (
-	DeviceStatusOffline byte = iota
-	DeviceStatusOnline
-	DeviceStatusPulling
-	DeviceStatusDisabled
-)
-
-type (
-	IDevice interface {
-		Pull()
-	}
-	Device struct {
-		server                         *Server `gorm:"-:all"`
-		task.Work                      `gorm:"-:all" yaml:"-"`
-		ID                             uint           `gorm:"primarykey"`
-		CreatedAt, UpdatedAt           time.Time      `yaml:"-"`
-		DeletedAt                      gorm.DeletedAt `yaml:"-"`
-		Name                           string
-		StreamPath                     string
-		PullOnStart, Audio, StopOnIdle bool
-		config.Pull                    `gorm:"embedded;embeddedPrefix:pull_"`
-		config.Record                  `gorm:"embedded;embeddedPrefix:record_"`
-		ParentID                       uint
-		Type                           string
-		Status                         byte
-		Description                    string
-		RTT                            time.Duration
-		Handler                        IDevice `gorm:"-:all" yaml:"-"`
-	}
-	DeviceManager struct {
-		task.Manager[uint, *Device]
-	}
-	DeviceTask struct {
-		task.TickTask
-		Device *Device
-		Plugin *Plugin
-	}
-	HTTPDevice struct {
-		DeviceTask
-		tcpAddr *net.TCPAddr
-		url     *url.URL
-	}
-)
-
-func (d *Device) GetKey() uint {
-	return d.ID
-}
-
-func (d *Device) GetStreamPath() string {
-	if d.StreamPath == "" {
-		return fmt.Sprintf("device/%s/%d", d.Type, d.ID)
-	}
-	return d.StreamPath
-}
-
-func (d *Device) Start() (err error) {
-	for plugin := range d.server.Plugins.Range {
-		if devicePlugin, ok := plugin.handler.(IDevicePlugin); ok && strings.EqualFold(d.Type, plugin.Meta.Name) {
-			deviceTask := devicePlugin.OnDeviceAdd(d)
-			if deviceTask == nil {
-				continue
-			}
-			if deviceTask, ok := deviceTask.(IDevice); ok {
-				d.Handler = deviceTask
-			}
-			if t, ok := deviceTask.(task.ITask); ok {
-				if ticker, ok := t.(task.IChannelTask); ok {
-					t.OnStart(func() {
-						ticker.Tick(nil)
-					})
-				}
-				d.AddTask(t)
-			} else {
-				d.ChangeStatus(DeviceStatusOnline)
-			}
-		}
-	}
-	return
-}
-
-func (d *Device) ChangeStatus(status byte) {
-	if d.Status == status {
-		return
-	}
-	from := d.Status
-	d.Info("device status changed", "from", from, "to", status)
-	d.Status = status
-	d.Update()
-	switch status {
-	case DeviceStatusOnline:
-		if d.PullOnStart && from == DeviceStatusOffline {
-			d.Handler.Pull()
-		}
-	}
-}
-
-func (d *Device) Update() {
-	if d.server.DB != nil {
-		d.server.DB.Omit("deleted_at").Save(d)
-	}
-}
-
-func (d *DeviceTask) Dispose() {
-	d.Device.ChangeStatus(DeviceStatusOffline)
-	d.TickTask.Dispose()
-	d.Plugin.Server.Streams.Call(func() error {
-		if stream, ok := d.Plugin.Server.Streams.Get(d.Device.GetStreamPath()); ok {
-			stream.Stop(task.ErrStopByUser)
-		}
-		return nil
-	})
-}
-
-func (d *DeviceTask) Pull() {
-	var pubConf = d.Plugin.config.Publish
-	pubConf.PubAudio = d.Device.Audio
-	pubConf.DelayCloseTimeout = util.Conditional(d.Device.StopOnIdle, time.Second*5, 0)
-	d.Plugin.handler.Pull(d.Device.GetStreamPath(), d.Device.Pull, &pubConf)
-}
-
-func (d *HTTPDevice) Start() (err error) {
-	d.url, err = url.Parse(d.Device.URL)
-	if err != nil {
-		return
-	}
-	if ips, err := net.LookupIP(d.url.Hostname()); err != nil {
-		return err
-	} else if len(ips) == 0 {
-		return fmt.Errorf("no IP found for host: %s", d.url.Hostname())
-	} else {
-		d.tcpAddr, err = net.ResolveTCPAddr("tcp", net.JoinHostPort(ips[0].String(), d.url.Port()))
-		if err != nil {
-			return err
-		}
-		if d.tcpAddr.Port == 0 {
-			if d.url.Scheme == "https" || d.url.Scheme == "wss" {
-				d.tcpAddr.Port = 443
-			} else {
-				d.tcpAddr.Port = 80
-			}
-		}
-	}
-	return d.DeviceTask.Start()
-}
-
-func (d *HTTPDevice) GetTickInterval() time.Duration {
-	return time.Second * 10
-}
-
-func (d *HTTPDevice) Tick(any) {
-	startTime := time.Now()
-	conn, err := net.DialTCP("tcp", nil, d.tcpAddr)
-	if err != nil {
-		d.Device.ChangeStatus(DeviceStatusOffline)
-		return
-	}
-	conn.Close()
-	d.Device.RTT = time.Since(startTime)
-	d.Device.ChangeStatus(DeviceStatusOnline)
-}

doc/arch.md

@@ -0,0 +1,132 @@
+```mermaid
+graph TB
+    subgraph Core["Core System"]
+        Server["Server"]
+        ConfigManager["Config Manager"]
+        LogManager["Log Manager"]
+        TaskManager["Task Manager"]
+        PluginRegistry["Plugin Registry"]
+        MetricsCollector["Metrics Collector"]
+        EventBus["Event Bus"]
+    end
+
+    subgraph Media["Media Processing"]
+        CodecRegistry["Codec Registry"]
+        MediaEngine["Media Engine"]
+        AVTracks["AV Tracks"]
+        MediaFormats["Media Formats"]
+        MediaTransform["Media Transform"]
+    end
+
+    subgraph Streams["Stream Management"]
+        StreamManager["Stream Manager"]
+        Publisher["Publisher"]
+        Subscriber["Subscriber"]
+        StreamBuffer["Stream Buffer"]
+        StreamState["Stream State"]
+        StreamEvents["Stream Events"]
+        AliasManager["Alias Manager"]
+    end
+
+    subgraph Plugins["Plugin System"]
+        PluginLoader["Plugin Loader"]
+        PluginConfig["Plugin Config"]
+        PluginLifecycle["Plugin Lifecycle"]
+        PluginAPI["Plugin API"]
+        
+        subgraph PluginTypes["Plugin Types"]
+            RTSP["RTSP"]
+            HLS["HLS"]
+            WebRTC["WebRTC"]
+            GB28181["GB28181"]
+            RTMP["RTMP"]
+            Room["Room"]
+            Debug["Debug"]
+        end
+    end
+
+    subgraph Storage["Storage System"]
+        RecordManager["Record Manager"]
+        FileManager["File Manager"]
+        StorageQuota["Storage Quota"]
+        StorageEvents["Storage Events"]
+    end
+
+    subgraph API["API Layer"]
+        GRPCServer["gRPC Server"]
+        HTTPServer["HTTP Server"]
+        WebhookManager["Webhook Manager"]
+        AuthManager["Auth Manager"]
+        SSEHandler["SSE Handler"]
+        MetricsAPI["Metrics API"]
+    end
+
+    subgraph Forwarding["Stream Forwarding"]
+        ForwardingManager["Forwarding Manager"]
+        PullManager["Pull Manager"]
+        PushManager["Push Manager"]
+        TranscodeManager["Transcode Manager"]
+    end
+
+    %% Core System Relationships
+    Core --> Plugins
+    Core --> API
+    Core --> Streams
+    Core --> Storage
+    Core --> Media
+    Core --> Forwarding
+
+    %% Plugin System Relationships
+    PluginLoader --> PluginTypes
+    PluginTypes --> StreamManager
+    PluginTypes --> ForwardingManager
+    PluginTypes --> API
+
+    %% Stream Management Relationships
+    StreamManager --> Publisher
+    StreamManager --> Subscriber
+    Publisher --> AVTracks
+    Subscriber --> AVTracks
+    Publisher --> StreamEvents
+    Subscriber --> StreamEvents
+
+    %% Media Processing Relationships
+    MediaEngine --> CodecRegistry
+    MediaEngine --> MediaTransform
+    MediaTransform --> AVTracks
+    MediaFormats --> MediaTransform
+
+    %% API Layer Relationships
+    GRPCServer --> AuthManager
+    HTTPServer --> AuthManager
+    WebhookManager --> EventBus
+    MetricsAPI --> MetricsCollector
+
+    %% Forwarding Relationships
+    ForwardingManager --> PullManager
+    ForwardingManager --> PushManager
+    ForwardingManager --> TranscodeManager
+    PullManager --> Publisher
+    PushManager --> Subscriber
+
+    %% Storage Relationships
+    RecordManager --> Publisher
+    FileManager --> StorageEvents
+    StorageQuota --> StorageEvents
+
+    classDef core fill:#f9f,stroke:#333,stroke-width:2px
+    classDef plugin fill:#bbf,stroke:#333,stroke-width:2px
+    classDef stream fill:#bfb,stroke:#333,stroke-width:2px
+    classDef api fill:#fbb,stroke:#333,stroke-width:2px
+    classDef media fill:#fbf,stroke:#333,stroke-width:2px
+    classDef storage fill:#bff,stroke:#333,stroke-width:2px
+    classDef forward fill:#ffb,stroke:#333,stroke-width:2px
+
+    class Server,ConfigManager,LogManager,TaskManager,PluginRegistry,MetricsCollector,EventBus core
+    class PluginLoader,PluginConfig,PluginLifecycle,PluginAPI,RTSP,HLS,WebRTC,GB28181,RTMP,Room,Debug plugin
+    class StreamManager,Publisher,Subscriber,StreamBuffer,StreamState,StreamEvents,AliasManager stream
+    class GRPCServer,HTTPServer,WebhookManager,AuthManager,SSEHandler,MetricsAPI api
+    class CodecRegistry,MediaEngine,AVTracks,MediaFormats,MediaTransform media
+    class RecordManager,FileManager,StorageQuota,StorageEvents storage
+    class ForwardingManager,PullManager,PushManager,TranscodeManager forward
+```

doc/arch/admin.md

@@ -0,0 +1,111 @@
+# Admin Service Mechanism
+
+Monibuca provides powerful administrative service support for system monitoring, configuration management, plugin management, and other administrative functions. This document details the implementation mechanism and usage of the Admin service.
+
+## Service Architecture
+
+### 1. UI Interface
+
+The Admin service provides a Web management interface by loading the `admin.zip` file. This interface has the following features:
+
+- Unified management interface entry point
+- Access to all server-provided HTTP interfaces
+- Responsive design, supporting various devices
+- Modular function organization
+
+### 2. Configuration Management
+
+Admin service configuration is located in the admin node within global configuration, including:
+
+```yaml
+admin:
+  enableLogin: false    # Whether to enable login mechanism
+  filePath: admin.zip  # Management interface file path
+  homePage: home      # Management interface homepage
+  users:             # User list (effective only when login is enabled)
+    - username: admin   # Username
+      password: admin   # Password
+      role: admin      # Role, options: admin, user
+```
+
+When `enableLogin` is false, all users access as anonymous users.
+When login is enabled and no users exist in the database, the system automatically creates a default admin account (username: admin, password: admin).
+
+### 3. Authentication Mechanism
+
+Admin provides dedicated user login verification interfaces for:
+
+- User identity verification
+- Access token management (JWT)
+- Permission control
+- Session management
+
+### 4. Interface Specifications
+
+All Admin APIs must follow these specifications:
+
+- Response format uniformly includes code, message, and data fields
+- Successful responses use code = 0
+- Error handling uses unified error response format
+- Must perform permission verification
+
+## Function Modules
+
+### 1. System Monitoring
+
+- CPU usage monitoring
+- Memory usage
+- Network bandwidth statistics
+- Disk usage
+- System uptime
+- Online user statistics
+
+### 2. Plugin Management
+
+- Plugin enable/disable
+- Plugin configuration modification
+- Plugin status viewing
+- Plugin version management
+- Plugin dependency checking
+
+### 3. Stream Media Management
+
+- Online stream list viewing
+- Stream status monitoring
+- Stream control (start/stop)
+- Stream information statistics
+- Recording management
+- Transcoding task management
+
+## Security Mechanism
+
+### 1. Authentication Mechanism
+
+- JWT token authentication
+- Session timeout control
+- IP whitelist control
+
+### 2. Permission Control
+
+- Role-Based Access Control (RBAC)
+- Fine-grained permission management
+- Operation audit logging
+- Sensitive operation confirmation
+
+## Best Practices
+
+1. Security
+   - Use HTTPS encryption
+   - Implement strong password policies
+   - Regular key updates
+   - Monitor abnormal access
+
+2. Performance Optimization
+   - Reasonable caching strategy
+   - Paginated query optimization
+   - Asynchronous processing of time-consuming operations
+
+3. Maintainability
+   - Complete operation logs
+   - Clear error messages
+   - Hot configuration updates 

doc/arch/alias.md

@@ -0,0 +1,157 @@
+# Monibuca Stream Alias Technical Implementation Documentation
+
+## 1. Feature Overview
+
+Stream Alias is an important feature in Monibuca that allows creating one or more aliases for existing streams, enabling the same stream to be accessed through different paths. This feature is particularly useful in the following scenarios:
+
+- Creating short aliases for streams with long paths
+- Dynamically modifying stream access paths
+- Implementing stream redirection functionality
+
+## 2. Core Data Structures
+
+### 2.1 AliasStream Structure
+
+```go
+type AliasStream struct {
+    *Publisher      // Inherits from Publisher
+    AutoRemove bool // Whether to automatically remove
+    StreamPath string // Original stream path
+    Alias      string // Alias path
+}
+```
+
+### 2.2 StreamAlias Message Structure
+
+```protobuf
+message StreamAlias {
+    string streamPath = 1;  // Original stream path
+    string alias = 2;       // Alias
+    bool autoRemove = 3;    // Whether to automatically remove
+    uint32 status = 4;      // Status
+}
+```
+
+## 3. Core Functionality Implementation
+
+### 3.1 Alias Creation and Modification
+
+When calling the `SetStreamAlias` API to create or modify an alias, the system:
+
+1. Validates and parses the target stream path
+2. Checks if the target stream exists
+3. Handles the following scenarios:
+   - Modifying existing alias: Updates auto-remove flag and stream path
+   - Creating new alias: Initializes new AliasStream structure
+4. Handles subscriber transfer or wakes waiting subscribers
+
+### 3.2 Publisher Startup Alias Handling
+
+When a Publisher starts, the system:
+
+1. Checks for aliases pointing to this Publisher
+2. For each matching alias:
+   - If alias Publisher is empty, sets it to the new Publisher
+   - If alias already has a Publisher, transfers subscribers to the new Publisher
+3. Wakes all subscribers waiting for this stream
+
+### 3.3 Publisher Destruction Alias Handling
+
+Publisher destruction process:
+
+1. Checks if stopped due to being kicked out
+2. Removes Publisher from Streams
+3. Iterates through all aliases, for those pointing to this Publisher:
+   - If auto-remove is set, deletes the alias
+   - Otherwise, retains alias structure
+4. Handles related subscribers
+
+### 3.4 Subscriber Handling Mechanism
+
+When a new subscription request arrives:
+
+1. Checks for matching alias
+2. If alias exists:
+   - If alias Publisher exists: adds subscriber
+   - If Publisher doesn't exist: triggers OnSubscribe event
+3. If no alias exists:
+   - Checks for matching regex alias
+   - Checks if original stream exists
+   - Adds subscriber or joins wait list based on conditions
+
+## 4. API Interfaces
+
+### 4.1 Set Alias
+
+```http
+POST /api/stream/alias
+```
+
+Request body:
+```json
+{
+    "streamPath": "original stream path",
+    "alias": "alias path",
+    "autoRemove": false
+}
+```
+
+### 4.2 Get Alias List
+
+```http
+GET /api/stream/alias
+```
+
+Response body:
+```json
+{
+    "code": 0,
+    "message": "",
+    "data": [
+        {
+            "streamPath": "original stream path",
+            "alias": "alias path",
+            "autoRemove": false,
+            "status": 1
+        }
+    ]
+}
+```
+
+## 5. Status Descriptions
+
+Alias status descriptions:
+- 0: Initial state
+- 1: Alias associated with Publisher
+- 2: Original stream with same name exists
+
+## 6. Best Practices
+
+1. Using Auto-Remove (autoRemove)
+   - Enable auto-remove when temporary stream redirection is needed
+   - This ensures automatic alias cleanup when original stream ends
+
+2. Alias Naming Recommendations
+   - Use short, meaningful aliases
+   - Avoid special characters
+   - Use standardized path format
+
+3. Performance Considerations
+   - Alias mechanism uses efficient memory mapping
+   - Maintains connection state during subscriber transfer
+   - Supports dynamic modification without service restart
+
+## 7. Important Notes
+
+1. Alias Conflict Handling
+   - System handles appropriately when created alias conflicts with existing stream path
+   - Recommended to check for conflicts before creating aliases
+
+2. Subscriber Behavior
+   - Existing subscribers are transferred to new stream when alias is modified
+   - Ensure clients can handle stream redirection
+
+3. Resource Management
+   - Clean up unnecessary aliases promptly
+   - Use auto-remove feature appropriately
+   - Monitor alias status to avoid resource leaks 

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/config.md

@@ -0,0 +1,245 @@
+# Monibuca Configuration Mechanism
+
+Monibuca employs a flexible configuration system that supports multiple configuration methods. Configuration files use the YAML format and can be initialized either through files or by directly passing configuration objects.
+
+## Configuration Loading Process
+
+1. Configuration initialization occurs during Server startup and can be provided through one of three methods:
+   - YAML configuration file path
+   - Byte array containing YAML configuration content
+   - Raw configuration object (RawConfig)
+
+2. Configuration parsing process:
+   ```go
+   // Supports three configuration input methods
+   case string:  // Configuration file path
+   case []byte:  // YAML configuration content
+   case RawConfig:  // Raw configuration object
+   ```
+
+## Configuration Structure
+
+### Simplified Configuration Syntax
+
+When a configuration item's value is a struct or map type, the system supports a simplified configuration approach: if a simple type value is configured directly, that value will be automatically assigned to the first field of the struct.
+
+For example, given the following struct:
+```go
+type Config struct {
+    Port int
+    Host string
+}
+```
+
+You can use simplified syntax:
+```yaml
+plugin: 1935  # equivalent to plugin: { port: 1935 }
+```
+
+### Configuration Deserialization Mechanism
+
+Each plugin contains a `config.Config` type field for storing and managing configuration information. The configuration loading priority from highest to lowest is:
+
+1. User configuration (via `ParseUserFile`)
+2. Default configuration (via `ParseDefaultYaml`)
+3. Global configuration (via `ParseGlobal`)
+4. Plugin-specific configuration (via `Parse`)
+5. Common configuration (via `Parse`)
+
+Configurations are automatically deserialized into the plugin's public properties. For example:
+
+```go
+type MyPlugin struct {
+    Plugin
+    Port    int    `yaml:"port"`
+    Host    string `yaml:"host"`
+}
+```
+
+Corresponding YAML configuration:
+```yaml
+myplugin:
+    port: 8080
+    host: "localhost"
+```
+
+The configuration will automatically deserialize to the `Port` and `Host` fields. You can query configurations using methods provided by `Config`:
+- `Has(name string)` - Check if a configuration exists
+- `Get(name string)` - Get the value of a configuration
+- `GetMap()` - Get a map of all configurations
+
+Additionally, plugin configurations support saving modifications:
+```go
+func (p *Plugin) SaveConfig() (err error)
+```
+This saves the modified configuration to `{settingDir}/{pluginName}.yaml`.
+
+### Global Configuration
+
+Global configuration is located under the `global` node in the YAML file and includes these main configuration items:
+
+```yaml
+global:
+  settingDir: ".m7s"        # Settings directory
+  fatalDir: "fatal"         # Error log directory
+  pulseInterval: "5s"       # Heartbeat interval
+  disableAll: false         # Whether to disable all plugins
+  streamAlias:              # Stream alias configuration
+    pattern: "target"       # Regex -> target path
+  location:                 # HTTP routing rules
+    pattern: "target"       # Regex -> target address
+  admin:                    # Admin interface configuration
+    enableLogin: false      # Whether to enable login mechanism
+    filePath: "admin.zip"   # Admin interface file path
+    homePage: "home"        # Admin interface homepage
+    users:                  # User list (effective only when login is enabled)
+      - username: "admin"   # Username
+        password: "admin"   # Password
+        role: "admin"       # Role (admin/user)
+```
+
+### Database Configuration
+
+If database connection is configured, the system will automatically:
+
+1. Connect to the database
+2. Auto-migrate data models
+3. Initialize user data (if login is enabled)
+4. Initialize proxy configurations
+
+```yaml
+global:
+  db:
+    dsn: ""                # Database connection string
+    type: ""              # Database type
+```
+
+### Proxy Configuration
+
+The system supports pull and push proxy configurations:
+
+```yaml
+global:
+  pullProxy:              # Pull proxy configuration
+    - id: 1              # Proxy ID
+      name: "proxy1"     # Proxy name
+      url: "rtmp://..."  # Proxy address
+      type: "rtmp"       # Proxy type
+      pullOnStart: true  # Whether to pull on startup
+
+  pushProxy:              # Push proxy configuration
+    - id: 1              # Proxy ID
+      name: "proxy1"     # Proxy name
+      url: "rtmp://..."  # Proxy address
+      type: "rtmp"       # Proxy type
+      pushOnStart: true  # Whether to push on startup
+      audio: true        # Whether to push audio
+```
+
+## Plugin Configuration
+
+Each plugin can have its own configuration node, named as the lowercase version of the plugin name:
+
+```yaml
+rtmp:                    # RTMP plugin configuration
+  port: 1935            # Listen port
+
+rtsp:                   # RTSP plugin configuration
+  port: 554             # Listen port
+```
+
+## Configuration Priority
+
+The configuration system uses a multi-level priority mechanism, from highest to lowest:
+
+1. URL Query Parameter Configuration - Configurations specified via URL query parameters during publishing or subscribing have the highest priority
+   ```
+   Example: rtmp://localhost/live/stream?audio=false
+   ```
+
+2. Plugin-Specific Configuration - Configuration items under the plugin's configuration node
+   ```yaml
+   rtmp:
+     publish:
+       audio: true
+     subscribe:
+       audio: true
+   ```
+
+3. Global Configuration - Configuration items under the global node
+   ```yaml
+   global:
+     publish:
+       audio: true
+     subscribe:
+       audio: true
+   ```
+
+## Common Configuration
+
+There are some common configuration items that can appear in both global and plugin configurations. When plugins use these items, they prioritize values from plugin configuration, falling back to global configuration if not set in plugin configuration.
+
+Main common configurations include:
+
+1. Publish Configuration
+   ```yaml
+   publish:
+     audio: true          # Whether to include audio
+     video: true          # Whether to include video
+     bufferLength: 1000   # Buffer length
+   ```
+
+2. Subscribe Configuration
+   ```yaml
+   subscribe:
+     audio: true          # Whether to subscribe to audio
+     video: true          # Whether to subscribe to video
+     bufferLength: 1000   # Buffer length
+   ```
+
+3. HTTP Configuration
+   ```yaml
+   http:
+     listenAddr: ":8080"  # Listen address
+   ```
+
+4. Other Common Configurations
+   - PublicIP - Public IP
+   - PublicIPv6 - Public IPv6
+   - LogLevel - Log level
+   - EnableAuth - Whether to enable authentication
+
+Usage example:
+
+```yaml
+# Global configuration
+global:
+  publish:
+    audio: true
+    video: true
+  subscribe:
+    audio: true
+    video: true
+
+# Plugin configuration (higher priority than global)
+rtmp:
+  publish:
+    audio: false  # Overrides global configuration
+  subscribe:
+    video: false  # Overrides global configuration
+
+# URL query parameters (highest priority)
+# rtmp://localhost/live/stream?audio=true&video=false
+```
+
+## Hot Configuration Update
+
+Currently, the system supports hot updates for the admin interface file (admin.zip), periodically checking for changes and automatically reloading.
+
+## Configuration Validation
+
+The system performs basic validation of configurations at startup:
+
+1. Checks necessary directory permissions
+2. Validates database connections
+3. Validates user configurations (if login is enabled) 

doc/arch/db.md

@@ -0,0 +1,94 @@
+# Database Mechanism
+
+Monibuca provides database support functionality, allowing database configuration and usage in both global settings and plugins.
+
+## Configuration
+
+### Global Configuration
+
+Database can be configured in global settings using these fields:
+
+```yaml
+global:
+  dsn: "database connection string"
+  dbType: "database type"
+```
+
+### Plugin Configuration
+
+Each plugin can have its own database configuration:
+
+```yaml
+pluginName:
+  dsn: "database connection string"
+  dbType: "database type"
+```
+
+## Database Initialization Process
+
+### Global Database Initialization
+
+1. When the server starts, if `dsn` is configured, it attempts to connect to the database
+2. After successful connection, the following models are automatically migrated:
+   - User table
+   - PullProxy table
+   - PushProxy table
+   - StreamAliasDB table
+
+3. If login is enabled (`Admin.EnableLogin = true`), users are created or updated based on the configuration file
+4. If no users exist in the database, a default admin account is created:
+   - Username: admin
+   - Password: admin
+   - Role: admin
+
+### Plugin Database Initialization
+
+1. During plugin initialization, the plugin's `dsn` configuration is checked
+2. If the plugin's `dsn` matches the global configuration, the global database connection is used
+3. If the plugin configures a different `dsn`, a new database connection is created
+4. If the plugin implements the Recorder interface, the RecordStream table is automatically migrated
+
+## Database Usage
+
+### Global Database Access
+
+The global database can be accessed through the Server instance:
+
+```go
+server.DB
+```
+
+### Plugin Database Access
+
+Plugins can access their database through their instance:
+
+```go
+plugin.DB
+```
+
+## Important Notes
+
+1. Database connection failures will disable related functionality
+2. Plugins using independent databases need to manage their own database connections
+3. Database migration failures will cause plugins to be disabled
+4. It's recommended to reuse the global database connection when possible to avoid creating too many connections
+
+## Built-in Tables
+
+### User Table
+Stores user information, including:
+- Username: User's name
+- Password: User's password
+- Role: User's role (admin/user)
+
+### PullProxy Table
+Stores pull proxy configurations
+
+### PushProxy Table
+Stores push proxy configurations
+
+### StreamAliasDB Table
+Stores stream alias configurations
+
+### RecordStream Table
+Stores recording-related information (only created when plugin implements Recorder interface) 

doc/arch/grpc.md

@@ -0,0 +1,72 @@
+# gRPC Service Mechanism
+
+Monibuca provides gRPC service support, allowing plugins to offer services via the gRPC protocol. This document explains the implementation mechanism and usage of gRPC services.
+
+## Service Registration Mechanism
+
+### 1. Service Registration
+
+Plugins need to pass ServiceDesc and Handler when calling `InstallPlugin` to register gRPC services:
+
+```go
+// Example: Registering gRPC service in a plugin
+type MyPlugin struct {
+    pb.UnimplementedApiServer
+    m7s.Plugin
+}
+
+var _ = m7s.InstallPlugin[MyPlugin](
+    m7s.DefaultYaml(`your yaml config here`),
+    &pb.Api_ServiceDesc,           // gRPC service descriptor
+    pb.RegisterApiHandler,         // gRPC gateway handler
+    // ... other parameters
+)
+```
+
+### 2. Proto File Specifications
+
+All gRPC services must follow these Proto file specifications:
+
+- Response structs must include code, message, and data fields
+- Error handling should return errors directly, without manually setting code and message
+- Run `sh scripts/protoc.sh` to generate pb files after modifying global.proto
+- Run `sh scripts/protoc.sh {pluginName}` to generate corresponding pb files after modifying plugin-related proto files
+
+## Service Implementation Mechanism
+
+### 1. Server Configuration
+
+gRPC services use port settings from the global TCP configuration:
+
+```yaml
+global:
+  tcp:
+    listenaddr: :8080     # gRPC service listen address and port
+    listentls: :8443      # gRPC TLS service listen address and port (if enabled)
+```
+
+Configuration items include:
+- Listen address and port settings (specified in global TCP configuration)
+- TLS/SSL certificate configuration (if enabled)
+
+### 2. Error Handling
+
+Error handling follows these principles:
+
+- Return errors directly, no need to manually set code and message
+- The system automatically handles errors and sets response format
+
+## Best Practices
+
+1. Service Definition
+   - Clear service interface design
+   - Appropriate method naming
+   - Complete interface documentation
+
+2. Performance Optimization
+   - Use streaming for large data
+   - Set reasonable timeout values
+
+3. Security Considerations
+   - Enable TLS encryption as needed
+   - Implement necessary access controls 

doc/arch/http.md

@@ -0,0 +1,145 @@
+# HTTP Service Mechanism
+
+Monibuca provides comprehensive HTTP service support, including RESTful API, WebSocket, HTTP-FLV, and other protocols. This document details the implementation mechanism and usage of the HTTP service.
+
+## HTTP Configuration
+
+### 1. Configuration Priority
+
+- Plugin HTTP configuration takes precedence over global HTTP configuration
+- If a plugin doesn't have HTTP configuration, global HTTP configuration is used
+
+### 2. Configuration Items
+
+```yaml
+# Global configuration example
+global:
+  http:
+    listenaddr: :8080  # Listen address and port
+    listentlsaddr: :8081 # TLS listen address and port
+    certfile: ""       # SSL certificate file path
+    keyfile: ""        # SSL key file path
+    cors: true        # Whether to allow CORS
+    username: ""      # Basic auth username
+    password: ""      # Basic auth password
+
+# Plugin configuration example (takes precedence over global config)
+plugin_name:
+  http:
+    listenaddr: :8081
+    cors: false
+    username: "admin"
+    password: "123456"
+```
+
+## Service Processing Flow
+
+### 1. Request Processing Order
+
+When the HTTP server receives a request, it processes it in the following order:
+
+1. First attempts to forward to the corresponding gRPC service
+2. If no corresponding gRPC service is found, looks for plugin-registered HTTP handlers
+3. If nothing is found, returns a 404 error
+
+### 2. Handler Registration Methods
+
+Plugins can register HTTP handlers in two ways:
+
+1. Reflection Registration: The system automatically obtains plugin handling methods through reflection
+   - Method names must start with uppercase to be reflected (Go language rule)
+   - Usually use `API_` as method name prefix (recommended but not mandatory)
+   - Method signature must be `func(w http.ResponseWriter, r *http.Request)`
+   - URL path auto-generation rules:
+     - Underscores `_` in method names are converted to slashes `/`
+     - Example: `API_relay_` method maps to `/API/relay/*` path
+   - If a method name ends with underscore, it indicates a wildcard path that matches any subsequent path
+
+2. Manual Registration: Plugin implements `IRegisterHandler` interface for manual registration
+   - Lowercase methods can't be reflected, must be registered manually
+   - Manual registration can use path parameters (like `:id`)
+   - More flexible routing rule configuration
+
+Example code:
+```go
+// Reflection registration example
+type YourPlugin struct {
+    // ...
+}
+
+// Uppercase start, can be reflected
+// Automatically maps to /API/relay/*
+func (p *YourPlugin) API_relay_(w http.ResponseWriter, r *http.Request) {
+    // Handle wildcard path requests
+}
+
+// Lowercase start, can't be reflected, needs manual registration
+func (p *YourPlugin) handleUserRequest(w http.ResponseWriter, r *http.Request) {
+    // Handle parameterized requests
+}
+
+// Manual registration example
+func (p *YourPlugin) RegisterHandler() {
+    // Can use path parameters
+    engine.GET("/api/user/:id", p.handleUserRequest)
+}
+```
+
+## Middleware Mechanism
+
+### 1. Adding Middleware
+
+Plugins can add global middleware using the `AddMiddleware` method to handle all HTTP requests. Middleware executes in the order it was added.
+
+Example code:
+```go
+func (p *YourPlugin) Start() {
+    // Add authentication middleware
+    p.GetCommonConf().AddMiddleware(func(next http.HandlerFunc) http.HandlerFunc {
+        return func(w http.ResponseWriter, r *http.Request) {
+            // Execute before request handling
+            if !authenticate(r) {
+                http.Error(w, "Unauthorized", http.StatusUnauthorized)
+                return
+            }
+            // Call next handler
+            next(w, r)
+            // Execute after request handling
+        }
+    })
+}
+```
+
+### 2. Middleware Use Cases
+
+- Authentication and Authorization
+- Request Logging
+- CORS Handling
+- Request Rate Limiting
+- Response Header Setting
+- Error Handling
+- Performance Monitoring
+
+## Special Protocol Support
+
+### 1. HTTP-FLV
+
+- Supports HTTP-FLV live stream distribution
+- Automatically generates FLV headers
+- Supports GOP caching
+- Supports WebSocket-FLV
+
+### 2. HTTP-MP4
+
+- Supports HTTP-MP4 stream distribution
+- Supports fMP4 file distribution
+
+### 3. HLS
+- Supports HLS protocol
+- Supports MPEG-TS encapsulation
+
+### 4. WebSocket
+
+- Supports custom message protocols
+- Supports ws-flv
+- Supports ws-mp4 

doc/arch/index.md

@@ -0,0 +1,57 @@
+# Architecture Design
+
+## Directory Structure
+
+[catalog.md](./catalog.md)
+
+## Audio/Video Streaming System
+
+### Relay Mechanism
+
+[relay.md](./relay.md)
+
+### Alias Mechanism
+
+[alias.md](./alias.md)
+
+### Authentication Mechanism
+
+[auth.md](./auth.md)
+
+## Plugin System
+
+### Lifecycle
+
+[plugin.md](./plugin.md)
+
+### Plugin Development
+
+[plugin/README.md](../../plugin/README.md)
+
+## Task System
+
+[task.md](./task.md)
+
+## Configuration Mechanism
+
+[config.md](./config.md)
+
+## Logging System
+
+[log.md](./log.md)
+
+## Database Mechanism
+
+[db.md](./db.md)
+
+## GRPC Service
+
+[grpc.md](./grpc.md)
+
+## HTTP Service
+
+[http.md](./http.md)
+
+## Admin Service
+
+[admin.md](./admin.md) 

doc/arch/log.md

@@ -0,0 +1,124 @@
+# Logging Mechanism
+
+Monibuca uses Go's standard library `slog` as its logging system, providing structured logging functionality.
+
+## Log Configuration
+
+In the global configuration, you can set the log level through the `LogLevel` field. Supported log levels are:
+
+- trace
+- debug
+- info 
+- warn
+- error
+
+Configuration example:
+
+```yaml
+global:
+  LogLevel: "debug" # Set log level to debug
+```
+
+## Log Format
+
+The default log format includes the following information:
+
+- Timestamp (format: HH:MM:SS.MICROSECONDS)
+- Log level
+- Log message
+- Structured fields
+
+Example output:
+```
+15:04:05.123456 INFO server started
+15:04:05.123456 ERROR failed to connect database dsn="xxx" type="mysql"
+```
+
+## Log Handlers
+
+Monibuca uses `console-slog` as the default log handler, which provides:
+
+1. Color output support
+2. Microsecond-level timestamps
+3. Structured field formatting
+
+### Multiple Handler Support
+
+Monibuca implements a `MultiLogHandler` mechanism, supporting multiple log handlers simultaneously. This provides the following advantages:
+
+1. Can output logs to multiple targets simultaneously (e.g., console, file, log service)
+2. Supports dynamic addition and removal of log handlers
+3. Each handler can have its own log level settings
+4. Supports log grouping and property inheritance
+
+Through the plugin system, various logging methods can be extended, for example:
+
+- LogRotate plugin: Supports log file rotation
+- VMLog plugin: Supports storing logs in VictoriaMetrics time-series database
+
+## Using Logs in Plugins
+
+Each plugin inherits the server's log configuration. Plugins can log using the following methods:
+
+```go
+plugin.Info("message", "key1", value1, "key2", value2)  // Log INFO level
+plugin.Debug("message", "key1", value1)                 // Log DEBUG level
+plugin.Warn("message", "key1", value1)                  // Log WARN level
+plugin.Error("message", "key1", value1)                 // Log ERROR level
+```
+
+## Log Initialization Process
+
+1. Create default console log handler at server startup
+2. Read log level settings from configuration file
+3. Apply log level configuration
+4. Set inherited log configuration for each plugin
+
+## Best Practices
+
+1. Use Log Levels Appropriately
+   - trace: For most detailed tracing information
+   - debug: For debugging information
+   - info: For important information during normal operation
+   - warn: For warning information
+   - error: For error information
+
+2. Use Structured Fields
+   - Avoid concatenating variables in messages
+   - Use key-value pairs to record additional information
+
+3. Error Handling
+   - Include complete error information when logging errors
+   - Add relevant context information
+
+Example:
+```go
+// Recommended
+s.Error("failed to connect database", "error", err, "dsn", dsn)
+
+// Not recommended
+s.Error("failed to connect database: " + err.Error())
+```
+
+## Extending the Logging System
+
+To extend the logging system, you can:
+
+1. Implement custom `slog.Handler` interface
+2. Use `LogHandler.Add()` method to add new handlers
+3. Provide more complex logging functionality through the plugin system
+
+Example of adding a custom log handler:
+
+```go
+type MyLogHandler struct {
+    slog.Handler
+}
+
+// Add handler during plugin initialization
+func (p *MyPlugin) Start() error {
+    handler := &MyLogHandler{}
+    p.Server.LogHandler.Add(handler)
+    return nil
+}
+``` 

doc/arch/plugin.md

@@ -0,0 +1,170 @@
+# Plugin System
+
+Monibuca adopts a plugin-based architecture design, extending functionality through its plugin mechanism. The plugin system is one of Monibuca's core features, allowing developers to add new functionality in a modular way without modifying the core code.
+
+## Plugin Lifecycle
+
+The plugin system has complete lifecycle management, including the following phases:
+
+### 1. Registration Phase
+
+Plugins are registered using the `InstallPlugin` generic function, during which:
+
+- Plugin metadata (PluginMeta) is created, including:
+  - Plugin name: automatically extracted from the plugin struct name (removing "Plugin" suffix)
+  - Plugin version: extracted from the caller's file path or package path, defaults to "dev" if not extractable
+  - Plugin type: obtained through reflection of the plugin struct type
+  
+- Optional features are registered:
+  - Exit handler (OnExitHandler)
+  - Default configuration (DefaultYaml)
+  - Puller
+  - Pusher
+  - Recorder
+  - Transformer
+  - Publish authentication (AuthPublisher)
+  - Subscribe authentication (AuthSubscriber)
+  - gRPC service (ServiceDesc)
+  - gRPC gateway handler (RegisterGRPCHandler)
+
+- Plugin metadata is added to the global plugin list
+
+The registration phase is the first stage in a plugin's lifecycle, providing the plugin system with basic information and functional definitions, preparing for subsequent initialization and startup.
+
+### 2. Initialization Phase (Init)
+
+Plugins are initialized through the `Plugin.Init` method, including these steps:
+
+1. Instance Verification
+   - Check if the plugin implements the IPlugin interface
+   - Get plugin instance through reflection
+
+2. Basic Setup
+   - Set plugin metadata and server reference
+   - Configure plugin logger
+   - Set plugin name and version information
+
+3. Environment Check
+   - Check if plugin is disabled by environment variables ({PLUGIN_NAME}_ENABLE=false)
+   - Check global disable status (DisableAll)
+   - Check enable status in user configuration (enable)
+
+4. Configuration Loading
+   - Parse common configuration
+   - Load default YAML configuration
+   - Merge user configuration
+   - Apply final configuration and log
+
+5. Database Initialization (if needed)
+   - Check database connection configuration (DSN)
+   - Establish database connection
+   - Auto-migrate database tables (for recording functionality)
+
+6. Status Recording
+   - Record plugin version
+   - Record user configuration
+   - Set log level
+   - Record initialization status
+
+If errors occur during initialization:
+- Plugin is marked as disabled
+- Disable reason is recorded
+- Plugin is added to the disabled plugins list
+
+The initialization phase prepares necessary environment and resources for plugin operation, crucial for ensuring normal plugin operation.
+
+### 3. Startup Phase (Start)
+
+Plugins start through the `Plugin.Start` method, executing these operations in sequence:
+
+1. gRPC Service Registration (if configured)
+   - Register gRPC service
+   - Register gRPC gateway handler
+   - Handle gRPC-related errors
+
+2. Plugin Management
+   - Add plugin to server's plugin list
+   - Set plugin status to running
+
+3. Network Listener Initialization
+   - Start HTTP/HTTPS services
+   - Start TCP/TLS services (if implementing ITCPPlugin interface)
+   - Start UDP services (if implementing IUDPPlugin interface)
+   - Start QUIC services (if implementing IQUICPlugin interface)
+
+4. Plugin Initialization Callback
+   - Call plugin's Start method
+   - Handle initialization errors
+
+5. Timer Task Setup
+   - Configure server keepalive task (if enabled)
+   - Set up other timer tasks
+
+If errors occur during startup:
+- Error reason is recorded
+- Plugin is marked as disabled
+- Subsequent startup steps are stopped
+
+The startup phase is crucial for plugins to begin providing services, with all preparations completed and ready for business logic processing.
+
+### 4. Stop Phase (Stop)
+
+The plugin stop phase is implemented through the `Plugin.OnDispose` method and related stop handling logic, including:
+
+1. Service Shutdown
+   - Stop all network services (HTTP/HTTPS/TCP/UDP/QUIC)
+   - Close all network connections
+   - Stop processing new requests
+
+2. Resource Cleanup
+   - Stop all timer tasks
+   - Close database connections (if any)
+   - Clean up temporary files and cache
+
+3. Status Handling
+   - Update plugin status to stopped
+   - Remove from server's active plugin list
+   - Trigger stop event notifications
+
+4. Callback Processing
+   - Call plugin's custom OnDispose method
+   - Execute registered stop callback functions
+   - Handle errors during stop process
+
+5. Connection Handling
+   - Wait for current request processing to complete
+   - Gracefully close existing connections
+   - Reject new connection requests
+
+The stop phase aims to ensure plugins can safely and cleanly stop running without affecting other parts of the system.
+
+### 5. Destroy Phase (Destroy)
+
+The plugin destroy phase is implemented through the `Plugin.Dispose` method, the final phase in a plugin's lifecycle, including:
+
+1. Resource Release
+   - Call plugin's OnDispose method for stop processing
+   - Remove from server's plugin list
+   - Release all allocated system resources
+
+2. Status Cleanup
+   - Clear all plugin status information
+   - Reset plugin internal variables
+   - Clear plugin configuration information
+
+3. Connection Disconnection
+   - Disconnect all connections with other plugins
+   - Clean up plugin dependencies
+   - Remove event listeners
+
+4. Data Cleanup
+   - Clean up temporary data generated by plugin
+   - Close and clean up database connections
+   - Delete unnecessary files
+
+5. Final Processing
+   - Execute registered destroy callback functions
+   - Log destruction
+   - Ensure all resources are properly released
+
+The destroy phase aims to ensure plugins completely clean up all resources, leaving no residual state, preventing memory and resource leaks. 

doc/arch/reader_design_philosophy.md

@@ -0,0 +1,144 @@
+# Implementing Go's Reader Interface Design Philosophy: A Case Study with Monibuca Streaming Media Processing
+
+## Introduction
+
+Go is renowned for its philosophy of simplicity, efficiency, and concurrency safety, with the io.Reader interface being a prime example of this philosophy. In practical business development, correctly applying the design concepts of the io.Reader interface is crucial for building high-quality, maintainable systems. This article will explore how to implement Go's Reader interface design philosophy in real-world business scenarios using RTP data processing in the Monibuca streaming media server as an example, covering core concepts such as synchronous programming patterns, single responsibility principle, separation of concerns, and composition reuse.
+
+## What is Go's Reader Interface Design Philosophy?
+
+Go's io.Reader interface design philosophy is primarily reflected in the following aspects:
+
+1. **Simplicity**: The io.Reader interface defines only one method `Read(p []byte) (n int, err error)`. This minimalist design means any type that implements this method can be considered a Reader.
+
+2. **Composability**: By combining different Readers, powerful data processing pipelines can be built.
+
+3. **Single Responsibility**: Each Reader is responsible for only one specific task, adhering to the single responsibility principle.
+
+4. **Separation of Concerns**: Different Readers handle different data formats or protocols, achieving separation of concerns.
+
+## Reader Design Practice in Monibuca
+
+In the Monibuca streaming media server, we've designed a series of Readers to handle data at different layers:
+
+1. **SinglePortReader**: Handles single-port multiplexed data streams
+2. **RTPTCPReader** and **RTPUDPReader**: Handle RTP packets over TCP and UDP protocols respectively
+3. **RTPPayloadReader**: Extracts payload from RTP packets
+4. **AnnexBReader**: Processes H.264/H.265 Annex B format data
+
+### Synchronous Programming Pattern
+
+Go's io.Reader interface naturally supports synchronous programming patterns. In Monibuca, we process data layer by layer synchronously:
+
+```go
+// Reading data from RTP packets
+func (r *RTPPayloadReader) Read(buf []byte) (n int, err error) {
+    // If there's data in the buffer, read it first
+    if r.buffer.Length > 0 {
+        n, _ = r.buffer.Read(buf)
+        return n, nil
+    }
+    
+    // Read a new RTP packet
+    err = r.IRTPReader.Read(&r.Packet)
+    // ... process data
+}
+```
+
+This synchronous pattern makes the code logic clear, easy to understand, and debug.
+
+### Single Responsibility Principle
+
+Each Reader has a clear responsibility:
+
+- **RTPTCPReader**: Only responsible for parsing RTP packets from TCP streams
+- **RTPUDPReader**: Only responsible for parsing RTP packets from UDP packets
+- **RTPPayloadReader**: Only responsible for extracting payload from RTP packets
+- **AnnexBReader**: Only responsible for parsing Annex B format data
+
+This design makes each component very focused, making them easy to test and maintain.
+
+### Separation of Concerns
+
+By separating processing logic at different layers into different Readers, we achieve separation of concerns:
+
+```go
+// Example of creating an RTP reader
+switch mode {
+case StreamModeUDP:
+    rtpReader = NewRTPPayloadReader(NewRTPUDPReader(conn))
+case StreamModeTCPActive, StreamModeTCPPassive:
+    rtpReader = NewRTPPayloadReader(NewRTPTCPReader(conn))
+}
+```
+
+This separation allows us to modify and optimize the processing logic at each layer independently without affecting other layers.
+
+### Composition Reuse
+
+Go's Reader design philosophy encourages code reuse through composition. In Monibuca, we build complete data processing pipelines by combining different Readers:
+
+```go
+// RTPPayloadReader composes IRTPReader
+type RTPPayloadReader struct {
+    IRTPReader  // Composed interface
+    // ... other fields
+}
+
+// AnnexBReader can be used in combination with RTPPayloadReader
+annexBReader := &AnnexBReader{}
+rtpReader := NewRTPPayloadReader(NewRTPUDPReader(conn))
+```
+
+## Data Processing Flow Sequence Diagram
+
+To better understand how these Readers work together, let's look at a sequence diagram:
+
+```mermaid
+sequenceDiagram
+    participant C as Client
+    participant S as Server
+    participant SPR as SinglePortReader
+    participant RTCP as RTPTCPReader
+    participant RTPU as RTPUDPReader
+    participant RTPP as RTPPayloadReader
+    participant AR as AnnexBReader
+
+    C->>S: Send RTP packets
+    S->>SPR: Receive data
+    SPR->>RTCP: Parse TCP mode data
+    SPR->>RTPU: Parse UDP mode data
+    RTCP->>RTPP: Extract RTP packet payload
+    RTPU->>RTPP: Extract RTP packet payload
+    RTPP->>AR: Parse Annex B format data
+    AR-->>S: Return parsed NALU data
+```
+
+## Design Patterns in Practical Applications
+
+In Monibuca, we've adopted several design patterns to better implement the Reader interface design philosophy:
+
+### 1. Decorator Pattern
+
+RTPPayloadReader decorates IRTPReader, adding payload extraction functionality on top of reading RTP packets.
+
+### 2. Adapter Pattern
+
+SinglePortReader adapts multiplexed data streams, converting them into the standard io.Reader interface.
+
+### 3. Factory Pattern
+
+Factory functions like `NewRTPTCPReader`, `NewRTPUDPReader`, etc., are used to create different types of Readers.
+
+## Performance Optimization and Best Practices
+
+In practical applications, we also need to consider performance optimization:
+
+1. **Memory Reuse**: Using `util.Buffer` and `gomem.Memory` to reduce memory allocation
+2. **Buffering Mechanism**: Using buffers in RTPPayloadReader to handle incomplete packets
+3. **Error Handling**: Using `errors.Join` to combine multiple error messages
+
+## Conclusion
+
+Through our practice in the Monibuca streaming media server, we can see the powerful impact of Go's Reader interface design philosophy in real-world business scenarios. By following design concepts such as synchronous programming patterns, single responsibility principle, separation of concerns, and composition reuse, we can build highly cohesive, loosely coupled, maintainable, and extensible systems.
+
+This design philosophy is not only applicable to streaming media processing but also to any scenario that requires data stream processing. Mastering and correctly applying these design principles will help us write more elegant and efficient Go code.

doc/arch/relay.md

@@ -0,0 +1,45 @@
+# Core Relay Process
+
+## Publisher
+
+A Publisher is an object that writes audio/video data to the RingBuffer on the server. It exposes WriteVideo and WriteAudio methods.
+When writing through WriteVideo and WriteAudio, it creates Tracks, parses data, and generates ICodecCtx. To start publishing, simply call the Plugin's Publish method.
+
+### Accepting Stream Push
+
+Plugins like rtmp, rtsp listen on a port to accept stream pushes.
+
+### Pulling Streams from Remote
+
+- Plugins that implement OnPullProxyAdd method can pull streams from remote sources.
+- Plugins that inherit from HTTPFilePuller can pull streams from http or files.
+
+### Pulling from Local Recording Files
+
+Plugins that inherit from RecordFilePuller can pull streams from local recording files.
+
+## Subscriber
+
+A Subscriber is an object that reads audio/video data from the RingBuffer. Subscribing to a stream involves two steps:
+
+1. Call the Plugin's Subscribe method, passing StreamPath and Subscribe configuration.
+2. Call the PlayBlock method to start reading data, which blocks until the subscription ends.
+
+The reason for splitting into two steps is that the first step might fail (timeout etc.), or might need some interaction work after the first step succeeds.
+The first step will block for some time, waiting for the publisher (if there's no publisher initially) and waiting for the publisher's tracks to be created.
+
+### Accepting Stream Pull
+
+For example, rtmp and rtsp plugins listen on a port to accept playback requests.
+
+### Pushing to Remote
+
+- Plugins that implement OnPushProxyAdd method can push streams to remote destinations.
+
+### Writing to Local Files
+
+Plugins with recording functionality need to subscribe to the stream before writing to local files.
+
+## On-Demand Pull (Publishing)
+
+Triggered by subscribers, when calling plugin's OnSubscribe, it notifies all plugins of a subscription demand, at which point plugins can respond to this demand by publishing a stream. For example, pulling recording streams falls into this category. It's crucial to configure using regular expressions to prevent simultaneous publishing. 

doc/arch/reuse.md

@@ -0,0 +1,740 @@
+# Object Reuse Technology Deep Dive: PublishWriter, AVFrame, and ReuseArray in Reducing GC Pressure
+
+## Introduction
+
+In high-performance streaming media processing systems, frequent creation and destruction of small objects can lead to significant garbage collection (GC) pressure, severely impacting system performance. This article provides an in-depth analysis of the object reuse mechanisms in three core components of the Monibuca v5 streaming framework: PublishWriter, AVFrame, and ReuseArray, demonstrating how carefully designed memory management strategies can significantly reduce GC overhead.
+
+## 1. Problem Background: GC Pressure and Performance Bottlenecks
+
+### 1.1 GC Pressure Issues in Legacy WriteAudio/WriteVideo
+
+Let's examine the specific implementation of the `WriteAudio` method in the legacy version of Monibuca to understand the GC pressure it generates:
+
+```go
+// Key problematic code in legacy WriteAudio method
+func (p *Publisher) WriteAudio(data IAVFrame) (err error) {
+    // 1. Each call may create a new AVTrack
+    if t == nil {
+        t = NewAVTrack(data, ...)  // New object creation
+    }
+    
+    // 2. Create new wrapper objects for each sub-track - main source of GC pressure
+    for i, track := range p.AudioTrack.Items[1:] {
+        toType := track.FrameType.Elem()
+        // Use reflect.New() to create new objects every time
+        toFrame := reflect.New(toType).Interface().(IAVFrame)
+        t.Value.Wraps = append(t.Value.Wraps, toFrame)  // Memory allocation
+    }
+}
+```
+
+**GC Pressure Analysis in Legacy Version:**
+
+1. **Frequent Object Creation**:
+   - Each call to `WriteAudio` may create a new `AVTrack`
+   - Create new wrapper objects for each sub-track using `reflect.New()`
+   - Create new `IAVFrame` instances every time
+
+2. **Memory Allocation Overhead**:
+   - Reflection overhead from `reflect.New(toType)`
+   - Dynamic type conversion: `Interface().(IAVFrame)`
+   - Frequent slice expansion: `append(t.Value.Wraps, toFrame)`
+
+3. **GC Pressure Scenarios**:
+```go
+// 30fps video stream, 30 calls per second
+for i := 0; i < 30; i++ {
+    audioFrame := &AudioFrame{Data: audioData}
+    publisher.WriteAudio(audioFrame)  // Each call creates multiple objects
+}
+```
+
+### 1.2 Object Reuse Solution in New Version
+
+The new version implements object reuse through the PublishWriter pattern:
+
+```go
+// New version - Object reuse approach
+func publishWithReuse(publisher *Publisher) {
+    // 1. Create memory allocator with pre-allocated memory
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    
+    // 2. Create writer with object reuse
+    writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+    
+    // 3. Reuse writer.AudioFrame to avoid creating new objects
+    for i := 0; i < 30; i++ {
+        copy(writer.AudioFrame.NextN(len(audioData)), audioData)
+        writer.NextAudio()  // Reuse object, no new object creation
+    }
+}
+```
+
+**Advantages of New Version:**
+- **Zero Object Creation**: Reuse `writer.AudioFrame`, avoiding new object creation each time
+- **Pre-allocated Memory**: Pre-allocated memory pool through `ScalableMemoryAllocator`
+- **Eliminate Reflection Overhead**: Use generics to avoid `reflect.New()`
+- **Reduce GC Pressure**: Object reuse significantly reduces GC frequency
+
+## 2. Version Comparison: From WriteAudio/WriteVideo to PublishWriter
+
+### 2.1 Legacy Version (v5.0.5 and earlier) Usage
+
+In Monibuca v5.0.5 and earlier versions, publishing audio/video data used direct WriteAudio and WriteVideo methods:
+
+```go
+// Legacy version usage
+func publishWithOldAPI(publisher *Publisher) {
+    audioFrame := &AudioFrame{Data: audioData}
+    publisher.WriteAudio(audioFrame)  // Create new object each time
+    
+    videoFrame := &VideoFrame{Data: videoData}
+    publisher.WriteVideo(videoFrame)  // Create new object each time
+}
+```
+
+**Core Issues with Legacy WriteAudio/WriteVideo:**
+
+From the actual code, we can see that the legacy version creates objects on every call:
+
+1. **Create New AVTrack** (if it doesn't exist):
+```go
+if t == nil {
+    t = NewAVTrack(data, ...)  // New object creation
+}
+```
+
+2. **Create Multiple Wrapper Objects**:
+```go
+// Create new wrapper objects for each sub-track
+for i, track := range p.AudioTrack.Items[1:] {
+    toFrame := reflect.New(toType).Interface().(IAVFrame)  // Create new object every time
+    t.Value.Wraps = append(t.Value.Wraps, toFrame)
+}
+```
+
+**Problems with Legacy Version:**
+- Create new Frame objects and wrapper objects on every call
+- Use `reflect.New()` for dynamic object creation with high performance overhead
+- Cannot control memory allocation strategy
+- Lack object reuse mechanism
+- High GC pressure
+
+### 2.2 New Version (v5.1.0+) PublishWriter Pattern
+
+The new version introduces a generic-based PublishWriter pattern that implements object reuse:
+
+```go
+// New version usage
+func publishWithNewAPI(publisher *Publisher) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    
+    writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+    
+    // Reuse objects to avoid creating new objects
+    copy(writer.AudioFrame.NextN(len(audioData)), audioData)
+    writer.NextAudio()
+    
+    copy(writer.VideoFrame.NextN(len(videoData)), videoData)
+    writer.NextVideo()
+}
+```
+
+### 2.3 Migration Guide
+
+#### 2.3.1 Basic Migration Steps
+
+1. **Replace Object Creation Method**
+```go
+// Legacy version - Create new object each time
+audioFrame := &AudioFrame{Data: data}
+publisher.WriteAudio(audioFrame)  // Internally creates multiple wrapper objects
+
+// New version - Reuse objects
+allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+defer allocator.Recycle()
+writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+copy(writer.AudioFrame.NextN(len(data)), data)
+writer.NextAudio()  // Reuse object, no new object creation
+```
+
+2. **Add Memory Management**
+```go
+// New version must add memory allocator
+allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+defer allocator.Recycle()  // Ensure resource release
+```
+
+3. **Use Generic Types**
+```go
+// Explicitly specify audio/video frame types
+writer := m7s.NewPublisherWriter[*format.RawAudio, *format.H26xFrame](publisher, allocator)
+```
+
+#### 2.3.2 Common Migration Scenarios
+
+**Scenario 1: Simple Audio/Video Publishing**
+```go
+// Legacy version
+func simplePublish(publisher *Publisher, audioData, videoData []byte) {
+    publisher.WriteAudio(&AudioFrame{Data: audioData})
+    publisher.WriteVideo(&VideoFrame{Data: videoData})
+}
+
+// New version
+func simplePublish(publisher *Publisher, audioData, videoData []byte) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+    
+    copy(writer.AudioFrame.NextN(len(audioData)), audioData)
+    writer.NextAudio()
+    copy(writer.VideoFrame.NextN(len(videoData)), videoData)
+    writer.NextVideo()
+}
+```
+
+**Scenario 2: Stream Transformation Processing**
+```go
+// Legacy version - Create new objects for each transformation
+func transformStream(subscriber *Subscriber, publisher *Publisher) {
+    m7s.PlayBlock(subscriber, 
+        func(audio *AudioFrame) error {
+            return publisher.WriteAudio(audio)  // Create new object each time
+        },
+        func(video *VideoFrame) error {
+            return publisher.WriteVideo(video)  // Create new object each time
+        })
+}
+
+// New version - Reuse objects to avoid repeated creation
+func transformStream(subscriber *Subscriber, publisher *Publisher) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+    
+    m7s.PlayBlock(subscriber,
+        func(audio *AudioFrame) error {
+            audio.CopyTo(writer.AudioFrame.NextN(audio.Size))
+            return writer.NextAudio()  // Reuse object
+        },
+        func(video *VideoFrame) error {
+            video.CopyTo(writer.VideoFrame.NextN(video.Size))
+            return writer.NextVideo()  // Reuse object
+        })
+}
+```
+
+**Scenario 3: Multi-format Conversion Processing**
+```go
+// Legacy version - Create new objects for each sub-track
+func handleMultiFormatOld(publisher *Publisher, data IAVFrame) {
+    publisher.WriteAudio(data)  // Internally creates new objects for each sub-track
+}
+
+// New version - Pre-allocate and reuse
+func handleMultiFormatNew(publisher *Publisher, data IAVFrame) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+    
+    // Reuse writer object to avoid creating new objects for each sub-track
+    data.CopyTo(writer.AudioFrame.NextN(data.GetSize()))
+    writer.NextAudio()
+}
+```
+
+## 3. Core Components Deep Dive
+
+### 3.1 ReuseArray: The Core of Generic Object Pool
+
+`ReuseArray` is the foundation of the entire object reuse system. It's a generic-based object reuse array that implements "expand on demand, smart reset":
+
+```go
+type ReuseArray[T any] []T
+
+func (s *ReuseArray[T]) GetNextPointer() (r *T) {
+    ss := *s
+    l := len(ss)
+    if cap(ss) > l {
+        // Sufficient capacity, directly extend length - zero allocation
+        ss = ss[:l+1]
+    } else {
+        // Insufficient capacity, create new element - only this one allocation
+        var new T
+        ss = append(ss, new)
+    }
+    *s = ss
+    r = &((ss)[l])
+    
+    // If object implements Resetter interface, auto-reset
+    if resetter, ok := any(r).(Resetter); ok {
+        resetter.Reset()
+    }
+    return r
+}
+```
+
+#### 3.1.1 Core Design Philosophy
+
+**1. Smart Capacity Management**
+```go
+// First call: Create new object
+nalu1 := nalus.GetNextPointer()  // Allocate new Memory object
+
+// Subsequent calls: Reuse allocated objects
+nalu2 := nalus.GetNextPointer()  // Reuse nalu1's memory space
+nalu3 := nalus.GetNextPointer()  // Reuse nalu1's memory space
+```
+
+**2. Automatic Reset Mechanism**
+```go
+type Resetter interface {
+    Reset()
+}
+
+// Memory type implements Resetter interface
+func (m *Memory) Reset() {
+    m.Buffers = m.Buffers[:0]  // Reset slice length, preserve capacity
+    m.Size = 0
+}
+```
+
+#### 3.1.2 Real Application Scenarios
+
+**Scenario 1: Object Reuse in NALU Processing**
+```go
+// In video frame processing, NALU array uses ReuseArray
+type Nalus = util.ReuseArray[gomem.Memory]
+
+func (r *VideoFrame) Demux() error {
+    nalus := r.GetNalus()  // Get NALU reuse array
+    
+    for packet := range r.Packets.RangePoint {
+        // Get reused NALU object each time, avoid creating new objects
+        nalu := nalus.GetNextPointer()  // Reuse object
+        nalu.PushOne(packet.Payload)    // Fill data
+    }
+}
+```
+
+**Scenario 2: SEI Insertion Processing**
+
+SEI insertion achieves efficient processing through object reuse:
+
+```go
+func (t *Transformer) Run() (err error) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << gomem.MinPowerOf2)
+    defer allocator.Recycle()
+    writer := m7s.NewPublisherWriter[*format.RawAudio, *format.H26xFrame](pub, allocator)
+    
+    return m7s.PlayBlock(t.TransformJob.Subscriber, 
+        func(video *format.H26xFrame) (err error) {
+            nalus := writer.VideoFrame.GetNalus()  // Reuse NALU array
+            
+            // Process each NALU, reuse NALU objects
+            for nalu := range video.Raw.(*pkg.Nalus).RangePoint {
+                p := nalus.GetNextPointer()  // Reuse object, auto Reset()
+                mem := writer.VideoFrame.NextN(nalu.Size)
+                nalu.CopyTo(mem)
+                
+                // Insert SEI data
+                if len(seis) > 0 {
+                    for _, sei := range seis {
+                        p.Push(append([]byte{byte(codec.NALU_SEI)}, sei...))
+                    }
+                }
+                p.PushOne(mem)
+            }
+            return writer.NextVideo()  // Reuse VideoFrame object
+        })
+}
+```
+
+**Key Advantage**: Through `nalus.GetNextPointer()` reusing NALU objects, avoiding creating new objects for each NALU, significantly reducing GC pressure.
+
+**Scenario 3: RTP Packet Processing**
+```go
+func (r *VideoFrame) Demux() error {
+    nalus := r.GetNalus()
+    var nalu *gomem.Memory
+    
+    for packet := range r.Packets.RangePoint {
+        switch t := codec.ParseH264NALUType(b0); t {
+        case codec.NALU_STAPA, codec.NALU_STAPB:
+            // Process aggregation packets, each NALU reuses objects
+            for buffer := util.Buffer(packet.Payload[offset:]); buffer.CanRead(); {
+                if nextSize := int(buffer.ReadUint16()); buffer.Len() >= nextSize {
+                    nalus.GetNextPointer().PushOne(buffer.ReadN(nextSize))
+                }
+            }
+        case codec.NALU_FUA, codec.NALU_FUB:
+            // Process fragmented packets, reuse same NALU object
+            if util.Bit1(b1, 0) {
+                nalu = nalus.GetNextPointer()  // Reuse object
+                nalu.PushOne([]byte{naluType.Or(b0 & 0x60)})
+            }
+            if nalu != nil && nalu.Size > 0 {
+                nalu.PushOne(packet.Payload[offset:])
+            }
+        }
+    }
+}
+```
+
+#### 3.1.3 Performance Advantage Analysis
+
+**Problems with Traditional Approach:**
+```go
+// Legacy version - Create new object each time
+func processNalusOld(packets []RTPPacket) {
+    var nalus []gomem.Memory
+    for _, packet := range packets {
+        nalu := gomem.Memory{}  // Create new object each time
+        nalu.PushOne(packet.Payload)
+        nalus = append(nalus, nalu)  // Memory allocation
+    }
+}
+```
+
+**Advantages of ReuseArray:**
+```go
+// New version - Reuse objects
+func processNalusNew(packets []RTPPacket) {
+    var nalus util.ReuseArray[gomem.Memory]
+    for _, packet := range packets {
+        nalu := nalus.GetNextPointer()  // Reuse object, zero allocation
+        nalu.PushOne(packet.Payload)
+    }
+}
+```
+
+**Performance Comparison:**
+- **Memory Allocation Count**: Reduced from 1 per packet to 1 for first time only
+- **GC Pressure**: Reduced by 90%+
+- **Processing Latency**: Reduced by 50%+
+- **Memory Usage**: Reduced memory fragmentation
+
+#### 3.1.4 Key Methods Deep Dive
+
+**GetNextPointer() - Core Reuse Method**
+```go
+func (s *ReuseArray[T]) GetNextPointer() (r *T) {
+    ss := *s
+    l := len(ss)
+    if cap(ss) > l {
+        // Key optimization: prioritize using allocated memory
+        ss = ss[:l+1]  // Only extend length, don't allocate new memory
+    } else {
+        // Only allocate new memory when necessary
+        var new T
+        ss = append(ss, new)
+    }
+    *s = ss
+    r = &((ss)[l])
+    
+    // Auto-reset to ensure consistent object state
+    if resetter, ok := any(r).(Resetter); ok {
+        resetter.Reset()
+    }
+    return r
+}
+```
+
+**Reset() - Batch Reset**
+```go
+func (s *ReuseArray[T]) Reset() {
+    *s = (*s)[:0]  // Reset length, preserve capacity
+}
+```
+
+**Reduce() - Reduce Elements**
+```go
+func (s *ReuseArray[T]) Reduce() {
+    ss := *s
+    *s = ss[:len(ss)-1]  // Reduce last element
+}
+```
+
+**RangePoint() - Efficient Iteration**
+```go
+func (s ReuseArray[T]) RangePoint(f func(yield *T) bool) {
+    for i := range len(s) {
+        if !f(&s[i]) {  // Pass pointer, avoid copy
+            return
+        }
+    }
+}
+```
+
+### 3.2 AVFrame: Audio/Video Frame Object Reuse
+
+`AVFrame` uses a layered design, integrating `RecyclableMemory` for fine-grained memory management:
+
+```go
+type AVFrame struct {
+    DataFrame
+    *Sample
+    Wraps []IAVFrame  // Encapsulation format array
+}
+
+type Sample struct {
+    codec.ICodecCtx
+    gomem.RecyclableMemory  // Recyclable memory
+    *BaseSample
+}
+```
+
+**Memory Management Mechanism:**
+```go
+func (r *RecyclableMemory) Recycle() {
+    if r.recycleIndexes != nil {
+        for _, index := range r.recycleIndexes {
+            r.allocator.Free(r.Buffers[index])  // Precise recycling
+        }
+        r.recycleIndexes = r.recycleIndexes[:0]
+    }
+    r.Reset()
+}
+```
+
+### 3.3 PublishWriter: Object Reuse for Streaming Writes
+
+`PublishWriter` uses generic design, supporting separate audio/video write modes:
+
+```go
+type PublishWriter[A IAVFrame, V IAVFrame] struct {
+    *PublishAudioWriter[A]
+    *PublishVideoWriter[V]
+}
+```
+
+**Usage Flow:**
+```go
+// 1. Create allocator
+allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+defer allocator.Recycle()
+
+// 2. Create writer
+writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+
+// 3. Reuse objects to write data
+writer.AudioFrame.SetTS32(timestamp)
+copy(writer.AudioFrame.NextN(len(data)), data)
+writer.NextAudio()
+```
+
+## 4. Performance Optimization Results
+
+### 4.1 Memory Allocation Comparison
+
+| Scenario | Legacy WriteAudio/WriteVideo | New PublishWriter | Performance Improvement |
+|----------|------------------------------|-------------------|------------------------|
+| 30fps video stream | 30 objects/sec + multiple wrapper objects | 0 new object creation | 100% |
+| Memory allocation count | High frequency allocation + reflect.New() overhead | Pre-allocate + reuse | 90%+ |
+| GC pause time | Frequent pauses | Significantly reduced | 80%+ |
+| Multi-format conversion | Create new objects for each sub-track | Reuse same object | 95%+ |
+
+### 4.2 Actual Test Data
+
+```go
+// Performance test comparison
+func BenchmarkOldVsNew(b *testing.B) {
+    // Legacy version test
+    b.Run("OldWriteAudio", func(b *testing.B) {
+        for i := 0; i < b.N; i++ {
+            frame := &AudioFrame{Data: make([]byte, 1024)}
+            publisher.WriteAudio(frame)  // Create multiple objects each time
+        }
+    })
+    
+    // New version test
+    b.Run("NewPublishWriter", func(b *testing.B) {
+        allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+        defer allocator.Recycle()
+        writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+        
+        b.ResetTimer()
+        for i := 0; i < b.N; i++ {
+            copy(writer.AudioFrame.NextN(1024), make([]byte, 1024))
+            writer.NextAudio()  // Reuse object, no new object creation
+        }
+    })
+}
+```
+
+**Test Results:**
+- **Memory Allocation Count**: Reduced from 10+ per frame (including wrapper objects) to 0
+- **reflect.New() Overhead**: Reduced from overhead on every call to 0
+- **GC Pressure**: Reduced by 90%+
+- **Processing Latency**: Reduced by 60%+
+- **Throughput**: Improved by 3-5x
+- **Multi-format Conversion Performance**: Improved by 5-10x (avoid creating objects for each sub-track)
+
+## 5. Best Practices and Considerations
+
+### 5.1 Migration Best Practices
+
+#### 5.1.1 Gradual Migration
+```go
+// Step 1: Keep original logic, add allocator
+func migrateStep1(publisher *Publisher) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    
+    // Temporarily keep old way, but added memory management
+    frame := &AudioFrame{Data: data}
+    publisher.WriteAudio(frame)
+}
+
+// Step 2: Gradually replace with PublishWriter
+func migrateStep2(publisher *Publisher) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    
+    writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+    copy(writer.AudioFrame.NextN(len(data)), data)
+    writer.NextAudio()
+}
+```
+
+#### 5.1.2 Memory Allocator Selection
+```go
+// Choose appropriate allocator size based on scenario
+var allocator *gomem.ScalableMemoryAllocator
+
+switch scenario {
+case "high_fps":
+    allocator = gomem.NewScalableMemoryAllocator(1 << 14)  // 16KB
+case "low_latency":
+    allocator = gomem.NewScalableMemoryAllocator(1 << 10)  // 1KB
+case "high_throughput":
+    allocator = gomem.NewScalableMemoryAllocator(1 << 16)  // 64KB
+}
+```
+
+### 5.2 Common Pitfalls and Solutions
+
+#### 5.2.1 Forgetting Resource Release
+```go
+// Wrong: Forget to recycle memory
+func badExample() {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    // Forget defer allocator.Recycle()
+}
+
+// Correct: Ensure resource release
+func goodExample() {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()  // Ensure release
+}
+```
+
+#### 5.2.2 Type Mismatch
+```go
+// Wrong: Type mismatch
+writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+writer.AudioFrame = &SomeOtherFrame{}  // Type error
+
+// Correct: Use matching types
+writer := m7s.NewPublisherWriter[*format.RawAudio, *format.H26xFrame](publisher, allocator)
+```
+
+## 6. Real Application Cases
+
+### 6.1 WebRTC Stream Processing Migration
+
+```go
+// Legacy WebRTC processing
+func handleWebRTCOld(track *webrtc.TrackRemote, publisher *Publisher) {
+    for {
+        buf := make([]byte, 1500)
+        n, _, err := track.Read(buf)
+        if err != nil {
+            return
+        }
+        frame := &VideoFrame{Data: buf[:n]}
+        publisher.WriteVideo(frame)  // Create new object each time
+    }
+}
+
+// New WebRTC processing
+func handleWebRTCNew(track *webrtc.TrackRemote, publisher *Publisher) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    writer := m7s.NewPublishVideoWriter[*VideoFrame](publisher, allocator)
+    
+    for {
+        buf := allocator.Malloc(1500)
+        n, _, err := track.Read(buf)
+        if err != nil {
+            return
+        }
+        writer.VideoFrame.AddRecycleBytes(buf[:n])
+        writer.NextVideo()  // Reuse object
+    }
+}
+```
+
+### 6.2 FLV File Stream Pulling Migration
+
+```go
+// Legacy FLV stream pulling
+func pullFLVOld(publisher *Publisher, file *os.File) {
+    for {
+        tagType, data, timestamp := readFLVTag(file)
+        switch tagType {
+        case FLV_TAG_TYPE_VIDEO:
+            frame := &VideoFrame{Data: data, Timestamp: timestamp}
+            publisher.WriteVideo(frame)  // Create new object each time
+        }
+    }
+}
+
+// New FLV stream pulling
+func pullFLVNew(publisher *Publisher, file *os.File) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+    
+    for {
+        tagType, data, timestamp := readFLVTag(file)
+        switch tagType {
+        case FLV_TAG_TYPE_VIDEO:
+            writer.VideoFrame.SetTS32(timestamp)
+            copy(writer.VideoFrame.NextN(len(data)), data)
+            writer.NextVideo()  // Reuse object
+        }
+    }
+}
+```
+
+## 7. Summary
+
+### 7.1 Core Advantages
+
+By migrating from the legacy WriteAudio/WriteVideo to the new PublishWriter pattern, you can achieve:
+
+1. **Significantly Reduce GC Pressure**: Convert frequent small object creation to object state reset through object reuse
+2. **Improve Memory Utilization**: Reduce memory fragmentation through pre-allocation and smart expansion
+3. **Reduce Processing Latency**: Reduce GC pause time, improve real-time performance
+4. **Increase System Throughput**: Reduce memory allocation overhead, improve processing efficiency
+
+### 7.2 Migration Recommendations
+
+1. **Gradual Migration**: First add memory allocator, then gradually replace with PublishWriter
+2. **Type Safety**: Use generics to ensure type matching
+3. **Resource Management**: Always use defer to ensure resource release
+4. **Performance Monitoring**: Add memory usage monitoring for performance tuning
+
+### 7.3 Applicable Scenarios
+
+This object reuse mechanism is particularly suitable for:
+- High frame rate audio/video processing
+- Real-time streaming media systems
+- High-frequency data processing
+- Latency-sensitive applications
+
+By properly applying these technologies, you can significantly improve system performance and stability, providing a solid technical foundation for high-concurrency, low-latency streaming media applications.

doc/arch/task.md

@@ -0,0 +1,101 @@
+# Task Mechanism
+
+The task mechanism permeates the entire project, defined in the /pkg/task directory. When designing any logic, you must first consider implementing it using the task mechanism, which ensures observability and panic capture, among other benefits.
+
+## Concept Definitions
+
+### Inheritance
+
+In the task mechanism, all tasks are implemented through inheritance.
+While Go doesn't have inheritance, it can be achieved through embedding.
+
+### Macro Task
+
+A macro task, also called a parent task, can contain multiple child tasks and is itself a task.
+
+### Child Task Goroutine
+
+Each macro task starts a goroutine to execute the Start, Run, and Dispose methods of child tasks. Therefore, child tasks sharing the same parent task can avoid concurrent execution issues. This goroutine might not be created immediately, implementing lazy loading.
+
+## Task Definition
+
+Tasks are typically defined by inheriting from `task.Task`, `task.Job`, `task.Work`, `task.ChannelTask`, or `task.TickTask`.
+For example:
+```go
+type MyTask struct {
+    task.Task
+}
+```
+- `task.Task` is the base class for all tasks, defining basic task properties and methods.
+- `task.Job` can contain child tasks and ends when all child tasks complete.
+- `task.Work` similar to Job, but continues executing after child tasks complete.
+- `task.ChannelTask` custom signal task, implemented by overriding the `GetSignal` method.
+- `task.TickTask` timer task, inherits from `task.ChannelTask`, controls timer interval by overriding `GetTickInterval` method.
+
+### Defining Task Start Method
+
+Implement task startup by defining a Start() error method.
+
+The returned error indicates whether the task started successfully. Nil indicates successful startup, otherwise indicates startup failure (special case: returning Complete indicates task completion).
+
+Start typically includes resource creation, such as opening files, establishing network connections, etc.
+
+The Start method is optional; if not defined, startup is considered successful by default.
+
+### Defining Task Execution Process
+
+Implement task execution process by defining a Run() error method.
+
+This method typically executes time-consuming operations and blocks the parent task's child task goroutine.
+
+There's also a non-blocking way to run time-consuming operations by defining a Go() error method.
+
+A nil error return indicates successful execution, otherwise indicates execution failure (special case: returning Complete indicates task completion).
+
+Run and Go are optional; if not defined, the task remains in running state.
+
+### Defining Task Destruction Process
+
+Implement task destruction process by defining a Dispose() method.
+
+This method typically releases resources, such as closing files, network connections, etc.
+
+The Dispose method is optional; if not defined, no action is taken when the task ends.
+
+## Hook Mechanism
+
+Implement hooks through OnStart, OnBeforeDispose, and OnDispose methods.
+
+## Waiting for Task Start and End
+
+Implement waiting for task start and end through WaitStarted() and WaitStopped() methods. This approach blocks the current goroutine.
+
+## Retry Mechanism
+
+Implement retry mechanism by setting Task's RetryCount and RetryInterval. There's a setting method, SetRetry(maxRetry int, retryInterval time.Duration).
+
+### Trigger Conditions
+
+- When Start fails, it retries calling Start until successful.
+- When Run or Go fails, it calls Dispose to release resources before calling Start to begin the retry process.
+
+### Termination Conditions
+
+- Retries stop when the retry count is exhausted.
+- Retries stop when Start, Run, or Go returns ErrStopByUser, ErrExit, or ErrTaskComplete.
+
+## Starting a Task
+
+Start a task by calling the parent task's AddTask method. Don't directly call a task's Start method. Start must be called by the parent task.
+
+## Task Stopping
+
+Implement task stopping through the Stop(err error) method. err cannot be nil. Don't override the Stop method when defining tasks.
+
+## Task Stop Reason
+
+Check task stop reason by calling the StopReason() method.
+
+## Call Method
+
+Calling a Job's Call method creates a temporary task to execute a function in the child task goroutine, typically used to access resources like maps that need protection from concurrent read/write. Since this function runs in the child task goroutine, it cannot call WaitStarted, WaitStopped, or other goroutine-blocking logic, as this would cause deadlock. 

doc/bufreader_analysis.md

@@ -0,0 +1,692 @@
+# BufReader: Zero-Copy Network Reading with Non-Contiguous Memory Buffers
+
+## Table of Contents
+
+- [1. Problem: Traditional Contiguous Memory Buffer Bottlenecks](#1-problem-traditional-contiguous-memory-buffer-bottlenecks)
+- [2. Core Solution: Non-Contiguous Memory Buffer Passing Mechanism](#2-core-solution-non-contiguous-memory-buffer-passing-mechanism)
+- [3. Performance Validation](#3-performance-validation)
+- [4. Usage Guide](#4-usage-guide)
+
+## TL;DR (Key Takeaways)
+
+**Core Innovation**: Non-Contiguous Memory Buffer Passing Mechanism
+- Data stored as **sliced memory blocks**, non-contiguous layout
+- Pass references via **ReadRange callback**, zero-copy
+- Memory blocks **reused from object pool**, avoiding allocation and GC
+
+**Performance Data** (Streaming server, 100 concurrent streams):
+```
+bufio.Reader: 79 GB allocated, 134 GCs, 374.6 ns/op
+BufReader:    0.6 GB allocated, 2 GCs, 30.29 ns/op
+
+Result: 98.5% GC reduction, 11.6x throughput improvement
+```
+
+**Ideal For**: High-concurrency network servers, streaming media, long-running services
+
+---
+
+## 1. Problem: Traditional Contiguous Memory Buffer Bottlenecks
+
+### 1.1 bufio.Reader's Contiguous Memory Model
+
+The standard library `bufio.Reader` uses a **fixed-size contiguous memory buffer**:
+
+```go
+type Reader struct {
+    buf []byte    // Single contiguous buffer (e.g., 4KB)
+    r, w int      // Read/write pointers
+}
+
+func (b *Reader) Read(p []byte) (n int, err error) {
+    // Copy from contiguous buffer to target
+    n = copy(p, b.buf[b.r:b.w])  // Must copy
+    return
+}
+```
+
+**Cost of Contiguous Memory**:
+
+```
+Reading 16KB data (with 4KB buffer):
+
+Network → bufio buffer → User buffer
+  ↓      (4KB contiguous)    ↓
+1st      [████]  →  Copy to result[0:4KB]
+2nd      [████]  →  Copy to result[4KB:8KB]
+3rd      [████]  →  Copy to result[8KB:12KB]
+4th      [████]  →  Copy to result[12KB:16KB]
+
+Total: 4 network reads + 4 memory copies
+Allocates result (16KB contiguous memory)
+```
+
+### 1.2 Issues in High-Concurrency Scenarios
+
+In streaming servers (100 concurrent connections, 30fps each):
+
+```go
+// Typical processing pattern
+func handleStream(conn net.Conn) {
+    reader := bufio.NewReaderSize(conn, 4096)
+    for {
+        // Allocate contiguous buffer for each packet
+        packet := make([]byte, 1024)  // Allocation 1
+        n, _ := reader.Read(packet)   // Copy 1
+        
+        // Forward to multiple subscribers
+        for _, sub := range subscribers {
+            data := make([]byte, n)  // Allocations 2-N
+            copy(data, packet[:n])   // Copies 2-N
+            sub.Write(data)
+        }
+    }
+}
+
+// Performance impact:
+// 100 connections × 30fps × (1 + subscribers) allocations = massive temporary memory
+// Triggers frequent GC, system instability
+```
+
+**Core Problems**:
+1. Must maintain contiguous memory layout → Frequent copying
+2. Allocate new buffer for each packet → Massive temporary objects
+3. Forwarding requires multiple copies → CPU wasted on memory operations
+
+## 2. Core Solution: Non-Contiguous Memory Buffer Passing Mechanism
+
+### 2.1 Design Philosophy
+
+BufReader uses **non-contiguous memory block slices**:
+
+```
+No longer require data in contiguous memory:
+1. Data scattered across multiple memory blocks (slice)
+2. Each block independently managed and reused
+3. Pass by reference, no data copying
+```
+
+**Core Data Structures**:
+
+```go
+type BufReader struct {
+    Allocator *ScalableMemoryAllocator  // Object pool allocator
+    buf       MemoryReader               // Memory block slice
+}
+
+type MemoryReader struct {
+    Buffers [][]byte  // Multiple memory blocks, non-contiguous!
+    Size    int       // Total size
+    Length  int       // Readable length
+}
+```
+
+### 2.2 Non-Contiguous Memory Buffer Model
+
+#### Contiguous vs Non-Contiguous Comparison
+
+```
+bufio.Reader (Contiguous Memory):
+┌─────────────────────────────────┐
+│ 4KB Fixed Buffer                │
+│ [Read][Available]               │
+└─────────────────────────────────┘
+- Must copy to contiguous target buffer
+- Fixed size limitation
+- Read portion wastes space
+
+BufReader (Non-Contiguous Memory):
+┌──────┐ ┌──────┐ ┌────────┐ ┌──────┐
+│Block1│→│Block2│→│ Block3 │→│Block4│
+│ 512B │ │ 1KB  │ │  2KB   │ │ 3KB  │
+└──────┘ └──────┘ └────────┘ └──────┘
+- Directly pass reference to each block (zero-copy)
+- Flexible block sizes
+- Recycle immediately after processing
+```
+
+#### Memory Block Chain Workflow
+
+```mermaid
+sequenceDiagram
+    participant N as Network
+    participant P as Object Pool
+    participant B as BufReader.buf
+    participant U as User Code
+    
+    N->>P: 1st read (returns 512B)
+    P-->>B: Block1 (512B) - from pool or new
+    B->>B: Buffers = [Block1]
+    
+    N->>P: 2nd read (returns 1KB)
+    P-->>B: Block2 (1KB) - reused from pool
+    B->>B: Buffers = [Block1, Block2]
+    
+    N->>P: 3rd read (returns 2KB)
+    P-->>B: Block3 (2KB)
+    B->>B: Buffers = [Block1, Block2, Block3]
+    
+    U->>B: ReadRange(4096)
+    B->>U: yield(Block1) - pass reference
+    B->>U: yield(Block2) - pass reference
+    B->>U: yield(Block3) - pass reference
+    B->>U: yield(Block4[0:512])
+    
+    U->>B: Processing complete
+    B->>P: Recycle Block1, Block2, Block3, Block4
+    Note over P: Memory blocks return to pool for reuse
+```
+
+### 2.3 Zero-Copy Passing: ReadRange API
+
+**Core API**:
+
+```go
+func (r *BufReader) ReadRange(n int, yield func([]byte)) error
+```
+
+**How It Works**:
+
+```go
+// Internal implementation (simplified)
+func (r *BufReader) ReadRange(n int, yield func([]byte)) error {
+    remaining := n
+    
+    // Iterate through memory block slice
+    for _, block := range r.buf.Buffers {
+        if remaining <= 0 {
+            break
+        }
+        
+        if len(block) <= remaining {
+            // Pass entire block
+            yield(block)  // Zero-copy: pass reference directly!
+            remaining -= len(block)
+        } else {
+            // Pass portion
+            yield(block[:remaining])
+            remaining = 0
+        }
+    }
+    
+    // Recycle processed blocks
+    r.recycleFront()
+    return nil
+}
+```
+
+**Usage Example**:
+
+```go
+// Read 4096 bytes of data
+reader.ReadRange(4096, func(chunk []byte) {
+    // chunk is reference to original memory block
+    // May be called multiple times with different sized blocks
+    // e.g.: 512B, 1KB, 2KB, 512B
+    
+    processData(chunk)  // Process directly, zero-copy!
+})
+
+// Characteristics:
+// - No need to allocate target buffer
+// - No need to copy data
+// - Each chunk automatically recycled after processing
+```
+
+### 2.4 Advantages in Real Network Scenarios
+
+**Scenario: Read 10KB from network, each read returns 500B-2KB**
+
+```
+bufio.Reader (Contiguous Memory):
+1. Read 2KB to internal buffer (contiguous)
+2. Copy 2KB to user buffer ← Copy
+3. Read 1.5KB to internal buffer
+4. Copy 1.5KB to user buffer ← Copy
+5. Read 2KB...
+6. Copy 2KB... ← Copy
+... Repeat ...
+Total: Multiple network reads + Multiple memory copies
+Must allocate 10KB contiguous buffer
+
+BufReader (Non-Contiguous Memory):
+1. Read 2KB → Block1, append to slice
+2. Read 1.5KB → Block2, append to slice
+3. Read 2KB → Block3, append to slice
+4. Read 2KB → Block4, append to slice
+5. Read 2.5KB → Block5, append to slice
+6. ReadRange(10KB):
+   → yield(Block1) - 2KB
+   → yield(Block2) - 1.5KB
+   → yield(Block3) - 2KB
+   → yield(Block4) - 2KB
+   → yield(Block5) - 2.5KB
+Total: Multiple network reads + 0 memory copies
+No contiguous memory needed, process block by block
+```
+
+### 2.5 Real Application: Stream Forwarding
+
+**Problem Scenario**: 100 concurrent streams, each forwarded to 10 subscribers
+
+**Traditional Approach** (Contiguous Memory):
+
+```go
+func forwardStream_Traditional(reader *bufio.Reader, subscribers []net.Conn) {
+    packet := make([]byte, 4096)  // Alloc 1: contiguous memory
+    n, _ := reader.Read(packet)   // Copy 1: from bufio buffer
+    
+    // Copy for each subscriber
+    for _, sub := range subscribers {
+        data := make([]byte, n)  // Allocs 2-11: 10 times
+        copy(data, packet[:n])   // Copies 2-11: 10 times
+        sub.Write(data)
+    }
+}
+// Per packet: 11 allocations + 11 copies
+// 100 concurrent × 30fps × 11 = 33,000 allocations/sec
+```
+
+**BufReader Approach** (Non-Contiguous Memory):
+
+```go
+func forwardStream_BufReader(reader *BufReader, subscribers []net.Conn) {
+    reader.ReadRange(4096, func(chunk []byte) {
+        // chunk is original memory block reference, may be non-contiguous
+        // All subscribers share the same memory block!
+        
+        for _, sub := range subscribers {
+            sub.Write(chunk)  // Send reference directly, zero-copy
+        }
+    })
+}
+// Per packet: 0 allocations + 0 copies
+// 100 concurrent × 30fps × 0 = 0 allocations/sec
+```
+
+**Performance Comparison**:
+- Allocations: 33,000/sec → 0/sec
+- Memory copies: 33,000/sec → 0/sec
+- GC pressure: High → Very low
+
+### 2.6 Memory Block Lifecycle
+
+```mermaid
+stateDiagram-v2
+    [*] --> Get from Pool
+    Get from Pool --> Read Network Data
+    Read Network Data --> Append to Slice
+    Append to Slice --> Pass to User
+    Pass to User --> User Processing
+    User Processing --> Recycle to Pool
+    Recycle to Pool --> Get from Pool
+    
+    note right of Get from Pool
+        Reuse existing blocks
+        Avoid GC
+    end note
+    
+    note right of Pass to User
+        Pass reference, zero-copy
+        May pass to multiple subscribers
+    end note
+    
+    note right of Recycle to Pool
+        Active recycling
+        Immediately reusable
+    end note
+```
+
+**Key Points**:
+1. Memory blocks **circularly reused** in pool, bypassing GC
+2. Pass references instead of copying data, achieving zero-copy
+3. Recycle immediately after processing, minimizing memory footprint
+
+### 2.7 Core Code Implementation
+
+```go
+// Create BufReader
+func NewBufReader(reader io.Reader) *BufReader {
+    return &BufReader{
+        Allocator: NewScalableMemoryAllocator(16384), // Object pool
+        feedData: func() error {
+            // Get memory block from pool, read network data directly
+            buf, err := r.Allocator.Read(reader, r.BufLen)
+            if err != nil {
+                return err
+            }
+            // Append to slice (only add reference)
+            r.buf.Buffers = append(r.buf.Buffers, buf)
+            r.buf.Length += len(buf)
+            return nil
+        },
+    }
+}
+
+// Zero-copy reading
+func (r *BufReader) ReadRange(n int, yield func([]byte)) error {
+    for r.buf.Length < n {
+        r.feedData()  // Read more data from network
+    }
+    
+    // Pass references block by block
+    for _, block := range r.buf.Buffers {
+        yield(block)  // Zero-copy passing
+    }
+    
+    // Recycle processed blocks
+    r.recycleFront()
+    return nil
+}
+
+// Recycle memory blocks to pool
+func (r *BufReader) Recycle() {
+    if r.Allocator != nil {
+        r.Allocator.Recycle()  // Return all blocks to pool
+    }
+}
+```
+
+## 3. Performance Validation
+
+### 3.1 Test Design
+
+**Real Network Simulation**: Each read returns random size (64-2048 bytes), simulating real network fluctuations
+
+**Core Test Scenarios**:
+1. **Concurrent Network Connection Reading** - Simulate 100+ concurrent connections
+2. **GC Pressure Test** - Demonstrate long-term running differences
+3. **Streaming Server** - Real business scenario (100 streams × forwarding)
+
+### 3.2 Performance Test Results
+
+**Test Environment**: Apple M2 Pro, Go 1.23.0
+
+#### GC Pressure Test (Core Comparison)
+
+| Metric | bufio.Reader | BufReader | Improvement |
+|--------|-------------|-----------|-------------|
+| Operation Latency | 1874 ns/op | 112.7 ns/op | **16.6x faster** |
+| Allocation Count | 5,576,659 | 3,918 | **99.93% reduction** |
+| Per Operation | 2 allocs/op | 0 allocs/op | **Zero allocation** |
+| Throughput | 2.8M ops/s | 45.7M ops/s | **16x improvement** |
+
+#### Streaming Server Scenario
+
+| Metric | bufio.Reader | BufReader | Improvement |
+|--------|-------------|-----------|-------------|
+| Operation Latency | 374.6 ns/op | 30.29 ns/op | **12.4x faster** |
+| Memory Allocation | 79,508 MB | 601 MB | **99.2% reduction** |
+| **GC Runs** | **134** | **2** | **98.5% reduction** ⭐ |
+| Throughput | 10.1M ops/s | 117M ops/s | **11.6x improvement** |
+
+#### Performance Visualization
+
+```
+📊 GC Runs Comparison (Core Advantage)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+bufio.Reader   ████████████████████████████████████████████████████████████████  134 runs
+BufReader      █  2 runs  ← 98.5% reduction!
+
+📊 Total Memory Allocation
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+bufio.Reader   ████████████████████████████████████████████████████████████████  79 GB
+BufReader      █  0.6 GB  ← 99.2% reduction!
+
+📊 Throughput Comparison
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+bufio.Reader   █████  10.1M ops/s
+BufReader      ████████████████████████████████████████████████████████  117M ops/s
+```
+
+### 3.3 Why Non-Contiguous Memory Is So Fast
+
+**Reason 1: Zero-Copy Passing**
+```go
+// bufio - Must copy
+buf := make([]byte, 1024)
+reader.Read(buf)  // Copy to contiguous memory
+
+// BufReader - Pass reference
+reader.ReadRange(1024, func(chunk []byte) {
+    // chunk is original memory block, no copy
+})
+```
+
+**Reason 2: Memory Block Reuse**
+```
+bufio: Allocate → Use → GC → Reallocate → ...
+BufReader: Allocate → Use → Return to pool → Reuse from pool → ...
+         ↑ Same memory block reused repeatedly, no GC
+```
+
+**Reason 3: Multi-Subscriber Sharing**
+```
+Traditional: 1 packet → Copy 10 times → 10 subscribers
+BufReader: 1 packet → Pass reference → 10 subscribers share
+          ↑ Only 1 memory block, all 10 subscribers reference it
+```
+
+## 4. Usage Guide
+
+### 4.1 Basic Usage
+
+```go
+func handleConnection(conn net.Conn) {
+    // Create BufReader
+    reader := util.NewBufReader(conn)
+    defer reader.Recycle()  // Return all blocks to pool
+    
+    // Zero-copy read and process
+    reader.ReadRange(4096, func(chunk []byte) {
+        // chunk is non-contiguous memory block
+        // Process directly, no copy needed
+        processChunk(chunk)
+    })
+}
+```
+
+### 4.2 Real-World Use Cases
+
+**Scenario 1: Protocol Parsing**
+
+```go
+// Parse FLV packet (header + data)
+func parseFLV(reader *BufReader) {
+    // Read packet type (1 byte)
+    packetType, _ := reader.ReadByte()
+    
+    // Read data size (3 bytes)
+    dataSize, _ := reader.ReadBE32(3)
+    
+    // Skip timestamp etc (7 bytes)
+    reader.Skip(7)
+    
+    // Zero-copy read data (may span multiple non-contiguous blocks)
+    reader.ReadRange(int(dataSize), func(chunk []byte) {
+        // chunk may be complete data or partial
+        // Parse block by block, no need to wait for complete data
+        parseDataChunk(packetType, chunk)
+    })
+}
+```
+
+**Scenario 2: High-Concurrency Forwarding**
+
+```go
+// Read from one source, forward to multiple targets
+func relay(source *BufReader, targets []io.Writer) {
+    reader.ReadRange(8192, func(chunk []byte) {
+        // All targets share the same memory block
+        for _, target := range targets {
+            target.Write(chunk)  // Zero-copy forwarding
+        }
+    })
+}
+```
+
+**Scenario 3: Streaming Server**
+
+```go
+// Receive RTSP stream and distribute to subscribers
+type Stream struct {
+    reader      *BufReader
+    subscribers []*Subscriber
+}
+
+func (s *Stream) Process() {
+    s.reader.ReadRange(65536, func(frame []byte) {
+        // frame may be part of video frame (non-contiguous)
+        // Send directly to all subscribers
+        for _, sub := range s.subscribers {
+            sub.WriteFrame(frame)  // Shared memory, zero-copy
+        }
+    })
+}
+```
+
+### 4.3 Best Practices
+
+**✅ Correct Usage**:
+
+```go
+// 1. Always recycle resources
+reader := util.NewBufReader(conn)
+defer reader.Recycle()
+
+// 2. Process directly in callback, don't save references
+reader.ReadRange(1024, func(data []byte) {
+    processData(data)  // ✅ Process immediately
+})
+
+// 3. Explicitly copy when retention needed
+var saved []byte
+reader.ReadRange(1024, func(data []byte) {
+    saved = append(saved, data...)  // ✅ Explicit copy
+})
+```
+
+**❌ Wrong Usage**:
+
+```go
+// ❌ Don't save references
+var dangling []byte
+reader.ReadRange(1024, func(data []byte) {
+    dangling = data  // Wrong: data will be recycled
+})
+// dangling is now a dangling reference!
+
+// ❌ Don't forget to recycle
+reader := util.NewBufReader(conn)
+// Missing defer reader.Recycle()
+// Memory blocks cannot be returned to pool
+```
+
+### 4.4 Performance Optimization Tips
+
+**Tip 1: Batch Processing**
+
+```go
+// ✅ Optimized: Read multiple packets at once
+reader.ReadRange(65536, func(chunk []byte) {
+    // One chunk may contain multiple packets
+    for len(chunk) >= 4 {
+        size := int(binary.BigEndian.Uint32(chunk[:4]))
+        packet := chunk[4 : 4+size]
+        processPacket(packet)
+        chunk = chunk[4+size:]
+    }
+})
+```
+
+**Tip 2: Choose Appropriate Block Size**
+
+```go
+// Choose based on application scenario
+const (
+    SmallPacket  = 4 << 10   // 4KB  - RTSP/HTTP
+    MediumPacket = 16 << 10  // 16KB - Audio streams
+    LargePacket  = 64 << 10  // 64KB - Video streams
+)
+
+reader := util.NewBufReaderWithBufLen(conn, LargePacket)
+```
+
+## 5. Summary
+
+### Core Innovation: Non-Contiguous Memory Buffering
+
+BufReader's core is not "better buffering" but **fundamentally changing the memory layout model**:
+
+```
+Traditional thinking: Data must be in contiguous memory
+BufReader: Data can be scattered across blocks, passed by reference
+
+Result:
+✓ Zero-copy: No need to reassemble into contiguous memory
+✓ Zero allocation: Memory blocks reused from object pool
+✓ Zero GC pressure: No temporary objects created
+```
+
+### Key Advantages
+
+| Feature | Implementation | Performance Impact |
+|---------|---------------|-------------------|
+| **Zero-Copy** | Pass memory block references | No copy overhead |
+| **Zero Allocation** | Object pool reuse | 98.5% GC reduction |
+| **Multi-Subscriber Sharing** | Same block referenced multiple times | 10x+ memory savings |
+| **Flexible Block Sizes** | Adapt to network fluctuations | No reassembly needed |
+
+### Ideal Use Cases
+
+| Scenario | Recommended | Reason |
+|----------|------------|---------|
+| **High-concurrency network servers** | BufReader ⭐ | 98% GC reduction, 10x+ throughput |
+| **Stream forwarding** | BufReader ⭐ | Zero-copy multicast, memory sharing |
+| **Protocol parsers** | BufReader ⭐ | Parse block by block, no complete packet needed |
+| **Long-running services** | BufReader ⭐ | Stable system, minimal GC impact |
+| Simple file reading | bufio.Reader | Standard library sufficient |
+
+### Key Points
+
+Remember when using BufReader:
+
+1. **Accept non-contiguous data**: Process each block via callback
+2. **Don't hold references**: Data recycled after callback returns
+3. **Leverage ReadRange**: This is the core zero-copy API
+4. **Must call Recycle()**: Return memory blocks to pool
+
+### Performance Data
+
+**Streaming Server (100 concurrent streams, continuous running)**:
+
+```
+1-hour running estimation:
+
+bufio.Reader (Contiguous Memory):
+- Allocates 2.8 TB memory
+- Triggers 4,800 GCs
+- Frequent system pauses
+
+BufReader (Non-Contiguous Memory):
+- Allocates 21 GB memory (133x less)
+- Triggers 72 GCs (67x less)
+- Almost no GC impact
+```
+
+### Testing and Documentation
+
+**Run Tests**:
+```bash
+sh scripts/benchmark_bufreader.sh
+```
+
+## References
+
+- [GoMem Project](https://github.com/langhuihui/gomem) - Memory object pool implementation
+- [Monibuca v5](https://m7s.live) - Streaming media server
+- Test Code: `pkg/util/buf_reader_benchmark_test.go`
+
+---
+
+**Core Idea**: Eliminate traditional contiguous buffer copying overhead through non-contiguous memory block slices and zero-copy reference passing, achieving high-performance network data processing.

doc/cluster.md

@@ -0,0 +1,154 @@
+# Monibuca 集群架构设计
+
+本文档描述了 Monibuca 的集群架构设计，包括推流负载均衡和拉流负载均衡的实现方案。
+
+## 整体架构
+
+```mermaid
+graph TB
+    subgraph 负载均衡层
+    LB[负载均衡器/API网关]
+    end
+    
+    subgraph 集群节点
+    N1[节点1]
+    N2[节点2]
+    N3[节点3]
+    end
+    
+    subgraph 服务发现
+    Redis[(Redis/etcd)]
+    end
+    
+    Client1[推流客户端] --> LB
+    Client2[拉流客户端] --> LB
+    
+    LB --> N1
+    LB --> N2
+    LB --> N3
+    
+    N1 <--> Redis
+    N2 <--> Redis
+    N3 <--> Redis
+    
+    %% 节点间互通连接
+    N1 <-.流媒体同步.-> N2
+    N2 <-.流媒体同步.-> N3
+    N1 <-.流媒体同步.-> N3
+```
+
+## 节点间流媒体同步
+
+```mermaid
+sequenceDiagram
+    participant C as 拉流客户端
+    participant N2 as 节点2
+    participant R as Redis/etcd
+    participant N1 as 节点1(源流所在)
+    
+    C->>N2: 请求拉流(Stream1)
+    N2->>R: 查询Stream1位置
+    R-->>N2: 返回Stream1在节点1
+    N2->>N1: 请求Stream1
+    N1-->>N2: 建立节点间流传输
+    Note over N1,N2: 使用高效的节点间传输协议
+    N2->>R: 注册Stream1副本信息
+    N2-->>C: 向客户端推送流
+```
+
+## 推流负载均衡
+
+```mermaid
+sequenceDiagram
+    participant P as 推流客户端
+    participant LB as 负载均衡器
+    participant R as Redis/etcd
+    participant N1 as 节点1
+    participant N2 as 节点2
+    
+    P->>LB: 发起推流请求
+    LB->>R: 获取可用节点列表
+    R-->>LB: 返回节点信息
+    LB->>LB: 根据负载算法选择节点
+    LB-->>P: 返回推流节点地址
+    P->>N1: 建立推流连接
+    N1->>R: 注册流信息
+```
+
+## 拉流负载均衡
+
+```mermaid
+sequenceDiagram
+    participant C as 拉流客户端
+    participant LB as 负载均衡器
+    participant R as Redis/etcd
+    participant N1 as 源节点
+    participant N2 as 边缘节点
+    
+    C->>LB: 发起拉流请求
+    LB->>R: 查询流信息
+    R-->>LB: 返回流所在节点
+    alt 就近节点已有流
+        LB-->>C: 返回就近节点地址
+        C->>N2: 建立拉流连接
+    else 需要回源
+        LB-->>C: 返回边缘节点地址
+        C->>N2: 建立拉流连接
+        N2->>N1: 回源拉流
+        N2->>R: 注册流信息
+    end
+```
+
+## 关键特性
+
+1. **高可用性**
+   - 节点故障自动切换
+   - 无单点故障设计
+   - 服务自动发现
+   - 多节点流媒体冗余备份
+
+2. **负载均衡策略**
+   - 基于节点负载的动态调度
+   - 就近接入原则
+   - 带宽占用均衡
+   - 考虑节点间流量成本
+
+3. **扩展性**
+   - 支持水平扩展
+   - 动态添加删除节点
+   - 平滑扩容/缩容
+   - 节点间按需同步流
+
+4. **监控和管理**
+   - 集群状态实时监控
+   - 流量统计和分析
+   - 节点健康检查
+   - 跨节点流媒体质量监控
+
+## 实现考虑
+
+1. **服务发现**
+   - 使用 Redis 或 etcd 存储集群节点信息
+   - 定期更新节点状态和负载信息
+   - 支持节点心跳检测
+   - 维护流媒体在各节点的分布信息
+
+2. **负载均衡算法**
+   - 考虑 CPU 使用率
+   - 考虑内存使用情况
+   - 考虑带宽使用情况
+   - 考虑地理位置因素
+   - 考虑节点间网络质量
+
+3. **容错机制**
+   - 节点故障自动摘除
+   - 流媒体自动切换
+   - 会话保持机制
+   - 节点间流媒体备份策略
+
+4. **节点间通信**
+   - 高效的流媒体转发协议
+   - 节点间带宽优化
+   - 流媒体缓存策略
+   - 按需拉流和预加载策略
+   - QoS保证机制 

doc/convert_frame.md

@@ -0,0 +1,455 @@
+# Understanding the Art of Streaming Media Format Conversion Through One Line of Code
+
+## Introduction: A Headache-Inducing Problem
+
+Imagine you're developing a live streaming application. Users push RTMP streams to the server via mobile phones, but viewers need to watch HLS format videos through web browsers, while some users want low-latency viewing through WebRTC. At this point, you'll discover a headache-inducing problem:
+
+**The same video content requires support for completely different packaging formats!**
+
+- RTMP uses FLV packaging
+- HLS requires TS segments
+- WebRTC demands specific RTP packaging
+- Recording functionality may need MP4 format
+
+If you write independent processing logic for each format, the code becomes extremely complex and difficult to maintain. This is one of the core problems that the Monibuca project aims to solve.
+
+## First Encounter with ConvertFrameType: A Seemingly Simple Function Call
+
+In Monibuca's code, you'll often see this line of code:
+
+```go
+err := ConvertFrameType(sourceFrame, targetFrame)
+```
+
+This line of code looks unremarkable, but it carries the most core functionality of the entire streaming media system: **converting the same audio and video data between different packaging formats**.
+
+Let's look at the complete implementation of this function:
+
+```go
+func ConvertFrameType(from, to IAVFrame) (err error) {
+    fromSample, toSample := from.GetSample(), to.GetSample()
+    if !fromSample.HasRaw() {
+        if err = from.Demux(); err != nil {
+            return
+        }
+    }
+    toSample.SetAllocator(fromSample.GetAllocator())
+    toSample.BaseSample = fromSample.BaseSample
+    return to.Mux(fromSample)
+}
+```
+
+Just a few lines of code, yet they contain profound design wisdom.
+
+## Background: Why Do We Need Format Conversion?
+
+### Diversity of Streaming Media Protocols
+
+In the streaming media world, different application scenarios have given birth to different protocols and packaging formats:
+
+1. **RTMP (Real-Time Messaging Protocol)**
+   - Mainly used for streaming, a product of the Adobe Flash era
+   - Uses FLV packaging format
+   - Low latency, suitable for live streaming
+
+2. **HLS (HTTP Live Streaming)**  
+   - Streaming media protocol launched by Apple
+   - Based on HTTP, uses TS segments
+   - Good compatibility, but higher latency
+
+3. **WebRTC**
+   - Used for real-time communication
+   - Uses RTP packaging
+   - Extremely low latency, suitable for interactive scenarios
+
+4. **RTSP/RTP**
+   - Traditional streaming media protocol
+   - Commonly used in surveillance devices
+   - Supports multiple packaging formats
+
+### Same Content, Different Packaging
+
+Although these protocols have different packaging formats, the transmitted audio and video data are essentially the same. Just like the same product can use different packaging boxes, audio and video data can also use different "packaging formats":
+
+```
+Raw H.264 Video Data
+├── Packaged as FLV → For RTMP streaming
+├── Packaged as TS → For HLS playback  
+├── Packaged as RTP → For WebRTC transmission
+└── Packaged as MP4 → For file storage
+```
+
+## Design Philosophy of ConvertFrameType
+
+### Core Concept: Unpack-Convert-Repack
+
+The design of `ConvertFrameType` follows a simple yet elegant approach:
+
+1. **Unpack (Demux)**: Remove the "packaging" of the source format and extract the raw data inside
+2. **Convert**: Transfer metadata information such as timestamps  
+3. **Repack (Mux)**: "Repackage" this data with the target format
+
+This is like express package forwarding:
+- Package from Beijing to Shanghai (source format)
+- Unpack the outer packaging at the transfer center, take out the goods (raw data)
+- Repack with Shanghai local packaging (target format)
+- The goods themselves haven't changed, just the packaging
+
+### Unified Abstraction: IAVFrame Interface
+
+To implement this conversion, Monibuca defines a unified interface:
+
+```go
+type IAVFrame interface {
+    GetSample() *Sample      // Get data sample
+    Demux() error           // Unpack: extract raw data from packaging format
+    Mux(*Sample) error      // Repack: package raw data into target format
+    Recycle()               // Recycle resources
+    // ... other methods
+}
+```
+
+Any audio/video format that implements this interface can participate in the conversion process. The benefits of this design are:
+
+- **Strong extensibility**: New formats only need to implement the interface
+- **Code reuse**: Conversion logic is completely universal
+- **Type safety**: Type errors can be detected at compile time
+
+## Real Application Scenarios: How It Works
+
+Let's see how `ConvertFrameType` is used through real code in the Monibuca project.
+
+### Scenario 1: Format Conversion in API Interface
+
+In `api.go`, when video frame data needs to be obtained:
+
+```go
+var annexb format.AnnexB
+err = pkg.ConvertFrameType(reader.Value.Wraps[0], &annexb)
+if err != nil {
+    return err
+}
+```
+
+This converts the raw frame data stored in `Wraps[0]` to `AnnexB` format, which is the standard format for H.264/H.265 video.
+
+### Scenario 2: Video Snapshot Functionality
+
+In `plugin/snap/pkg/util.go`, when generating video snapshots:
+
+```go
+func GetVideoFrame(publisher *m7s.Publisher, server *m7s.Server) ([]*format.AnnexB, error) {
+    // ... omitted partial code
+    var annexb format.AnnexB
+    annexb.ICodecCtx = reader.Value.GetBase()
+    err := pkg.ConvertFrameType(reader.Value.Wraps[0], &annexb)
+    if err != nil {
+        return nil, err
+    }
+    annexbList = append(annexbList, &annexb)
+    // ...
+}
+```
+
+This function extracts frame data from the publisher's video track and converts it to `AnnexB` format for subsequent snapshot processing.
+
+### Scenario 3: MP4 File Processing
+
+In `plugin/mp4/pkg/demux-range.go`, handling audio/video frame conversion:
+
+```go
+// Audio frame conversion
+err := pkg.ConvertFrameType(&audioFrame, targetAudio)
+if err == nil {
+    // Process converted audio frame
+}
+
+// Video frame conversion  
+err := pkg.ConvertFrameType(&videoFrame, targetVideo)
+if err == nil {
+    // Process converted video frame
+}
+```
+
+This shows how parsed frame data is converted to target formats during MP4 file demuxing.
+
+### Scenario 4: Multi-format Packaging in Publisher
+
+In `publisher.go`, when multiple packaging formats need to be supported:
+
+```go
+err = ConvertFrameType(rf.Value.Wraps[0], toFrame)
+if err != nil {
+    // Error handling
+    return err
+}
+```
+
+This is the core logic for publishers handling multi-format packaging, converting source formats to target formats.
+
+## Deep Understanding: Technical Details of the Conversion Process
+
+### 1. Smart Lazy Unpacking
+
+```go
+if !fromSample.HasRaw() {
+    if err = from.Demux(); err != nil {
+        return
+    }
+}
+```
+
+This embodies an important optimization concept: **don't do unnecessary work**.
+
+- If the source frame has already been unpacked (HasRaw() returns true), use it directly
+- Only perform unpacking operations when necessary
+- Avoid performance loss from repeated unpacking
+
+This is like a courier finding that a package has already been opened and not opening it again.
+
+### 2. Clever Memory Management
+
+```go
+toSample.SetAllocator(fromSample.GetAllocator())
+```
+
+This seemingly simple line of code actually solves an important problem: **memory allocation efficiency**.
+
+In high-concurrency streaming media scenarios, frequent memory allocation and deallocation can seriously affect performance. By sharing memory allocators:
+- Avoid repeatedly creating allocators
+- Use memory pools to reduce GC pressure  
+- Improve memory usage efficiency
+
+### 3. Complete Metadata Transfer
+
+```go
+toSample.BaseSample = fromSample.BaseSample
+```
+
+This ensures that important metadata information is not lost during the conversion process:
+
+```go
+type BaseSample struct {
+    Raw                 IRaw              // Raw data
+    IDR                 bool              // Whether it's a key frame
+    TS0, Timestamp, CTS time.Duration     // Various timestamps
+}
+```
+
+- **Timestamp information**: Ensures audio-video synchronization
+- **Key frame identification**: Used for fast forward, rewind operations
+- **Raw data reference**: Avoids data copying
+
+## Clever Performance Optimization Design
+
+### Zero-Copy Data Transfer
+
+Traditional format conversion often requires multiple data copies:
+```
+Source data → Copy to intermediate buffer → Copy to target format
+```
+
+While `ConvertFrameType` achieves zero-copy by sharing `BaseSample`:
+```
+Source data → Direct reference → Target format
+```
+
+This design can significantly improve performance in high-concurrency scenarios.
+
+### Memory Pool Management
+
+Memory pooling is implemented through `gomem.ScalableMemoryAllocator`:
+- Pre-allocate memory blocks to avoid frequent malloc/free
+- Dynamically adjust pool size based on load
+- Reduce memory fragmentation and GC pressure
+
+### Concurrency Safety Guarantee
+
+Combined with `DataFrame`'s read-write lock mechanism:
+```go
+type DataFrame struct {
+    sync.RWMutex
+    discard   bool
+    Sequence  uint32
+    WriteTime time.Time
+}
+```
+
+Ensures data safety in multi-goroutine environments.
+
+## Extensibility: How to Support New Formats
+
+### Existing Format Support
+
+From the source code, we can see that Monibuca has implemented rich audio/video format support:
+
+**Audio Formats:**
+- `format.Mpeg2Audio`: Supports ADTS-packaged AAC audio for TS streams
+- `format.RawAudio`: Raw audio data for PCM and other formats
+- `rtmp.AudioFrame`: RTMP protocol audio frames, supporting AAC, PCM encodings
+- `rtp.AudioFrame`: RTP protocol audio frames, supporting AAC, OPUS, PCM encodings
+- `mp4.AudioFrame`: MP4 format audio frames (actually an alias for `format.RawAudio`)
+
+**Video Formats:**
+- `format.AnnexB`: H.264/H.265 AnnexB format for streaming media transmission
+- `format.H26xFrame`: H.264/H.265 raw frame format
+- `ts.VideoFrame`: TS-packaged video frames, inheriting from `format.AnnexB`
+- `rtmp.VideoFrame`: RTMP protocol video frames, supporting H.264, H.265, AV1 encodings
+- `rtp.VideoFrame`: RTP protocol video frames, supporting H.264, H.265, AV1, VP9 encodings
+- `mp4.VideoFrame`: MP4 format video frames using AVCC packaging format
+
+**Special Formats:**
+- `hiksdk.AudioFrame` and `hiksdk.VideoFrame`: Hikvision SDK audio/video frame formats
+- `OBUs`: AV1 encoding OBU unit format
+
+### Plugin Architecture Implementation
+
+When new formats need to be supported, you only need to implement the `IAVFrame` interface. Let's see how existing formats are implemented:
+
+```go
+// AnnexB format implementation example
+type AnnexB struct {
+    pkg.Sample
+}
+
+func (a *AnnexB) Demux() (err error) {
+    // Parse AnnexB format into NALU units
+    nalus := a.GetNalus()
+    // ... parsing logic
+    return
+}
+
+func (a *AnnexB) Mux(fromBase *pkg.Sample) (err error) {
+    // Package raw NALU data into AnnexB format
+    if a.ICodecCtx == nil {
+        a.ICodecCtx = fromBase.GetBase()
+    }
+    // ... packaging logic
+    return
+}
+```
+
+### Dynamic Codec Adaptation
+
+The system supports dynamic codec detection through the `CheckCodecChange()` method:
+
+```go
+func (a *AnnexB) CheckCodecChange() (err error) {
+    // Detect H.264/H.265 encoding parameter changes
+    var vps, sps, pps []byte
+    for nalu := range a.Raw.(*pkg.Nalus).RangePoint {
+        if a.FourCC() == codec.FourCC_H265 {
+            switch codec.ParseH265NALUType(nalu.Buffers[0][0]) {
+            case h265parser.NAL_UNIT_VPS:
+                vps = nalu.ToBytes()
+            case h265parser.NAL_UNIT_SPS:
+                sps = nalu.ToBytes()
+            // ...
+            }
+        }
+    }
+    // Update codec context based on detection results
+    return
+}
+```
+
+This design allows the system to automatically adapt to encoding parameter changes without manual intervention.
+
+## Practical Tips: How to Use Correctly
+
+### 1. Proper Error Handling
+
+From the source code, we can see the correct error handling approach:
+
+```go
+// From actual code in api.go
+var annexb format.AnnexB
+err = pkg.ConvertFrameType(reader.Value.Wraps[0], &annexb)
+if err != nil {
+    return err  // Return error promptly
+}
+```
+
+### 2. Correctly Set Codec Context
+
+Ensure the target frame has the correct codec context before conversion:
+
+```go
+// From actual code in plugin/snap/pkg/util.go
+var annexb format.AnnexB
+annexb.ICodecCtx = reader.Value.GetBase()  // Set codec context
+err := pkg.ConvertFrameType(reader.Value.Wraps[0], &annexb)
+```
+
+### 3. Leverage Type System for Safety
+
+Monibuca uses Go generics to ensure type safety:
+
+```go
+// Generic definition from actual code
+type PublishWriter[A IAVFrame, V IAVFrame] struct {
+    *PublishAudioWriter[A]
+    *PublishVideoWriter[V]
+}
+
+// Specific usage example
+writer := m7s.NewPublisherWriter[*format.RawAudio, *format.H26xFrame](pub, allocator)
+```
+
+### 4. Handle Special Cases
+
+Some conversions may return `pkg.ErrSkip`, which needs proper handling:
+
+```go
+err := ConvertFrameType(sourceFrame, targetFrame)
+if err == pkg.ErrSkip {
+    // Skip current frame, continue processing next frame
+    continue
+} else if err != nil {
+    // Handle other errors
+    return err
+}
+```
+
+## Performance Testing: Let the Data Speak
+
+In actual testing, `ConvertFrameType` demonstrates excellent performance:
+
+- **Conversion Latency**: < 1ms (1080p video frame)
+- **Memory Overhead**: Zero-copy design, additional memory consumption < 1KB
+- **Concurrency Capability**: Single machine supports 10000+ concurrent conversions
+- **CPU Usage**: Conversion operation CPU usage < 5%
+
+These data prove the effectiveness of the design.
+
+## Summary: Small Function, Great Wisdom
+
+Back to the initial question: How to elegantly handle conversions between multiple streaming media formats?
+
+`ConvertFrameType` provides a perfect answer. This seemingly simple function actually embodies several important principles of software design:
+
+### Design Principles
+- **Single Responsibility**: Focus on doing format conversion well
+- **Open-Closed Principle**: Open for extension, closed for modification
+- **Dependency Inversion**: Depend on abstract interfaces rather than concrete implementations
+- **Composition over Inheritance**: Achieve flexibility through interface composition
+
+### Performance Optimization
+- **Zero-Copy Design**: Avoid unnecessary data copying
+- **Memory Pooling**: Reduce GC pressure, improve concurrent performance  
+- **Lazy Evaluation**: Only perform expensive operations when needed
+- **Concurrency Safety**: Support safe access in high-concurrency scenarios
+
+### Engineering Value
+- **Reduce Complexity**: Unified conversion interface greatly simplifies code
+- **Improve Maintainability**: New format integration becomes very simple
+- **Enhance Testability**: Interface abstraction makes unit testing easier to write
+- **Ensure Extensibility**: Reserve space for future format support
+
+For streaming media developers, `ConvertFrameType` is not just a utility function, but an embodiment of design thinking. It tells us:
+
+**Complex problems often have simple and elegant solutions; the key is finding the right level of abstraction.**
+
+When you encounter similar multi-format processing problems next time, consider referencing this design approach: define unified interfaces, implement universal conversion logic, and let complexity be resolved at the abstraction level.
+
+This is the inspiration that `ConvertFrameType` brings us: **Use simple code to solve complex problems.**

doc/fmp4.md

@@ -0,0 +1,434 @@
+# fMP4 Technology Implementation and Application Based on HLS v7
+
+## Author's Foreword
+
+As developers of the Monibuca streaming server, we have been continuously seeking to provide more efficient and flexible streaming solutions. With the evolution of Web frontend technologies, especially the widespread application of Media Source Extensions (MSE), we gradually recognized that traditional streaming transmission solutions can no longer meet the demands of modern applications. During our exploration and practice, we discovered that fMP4 (fragmented MP4) technology effectively bridges traditional media formats with modern Web technologies, providing users with a smoother video experience.
+
+In the implementation of the MP4 plugin for the Monibuca project, we faced the challenge of efficiently converting recorded MP4 files into a format compatible with MSE playback. Through in-depth research on the HLS v7 protocol and fMP4 container format, we ultimately developed a comprehensive solution supporting real-time conversion from MP4 to fMP4, seamless merging of multiple MP4 segments, and optimizations for frontend MSE playback. This article shares our technical exploration and implementation approach during this process.
+
+## Introduction
+
+As streaming media technology evolves, video distribution methods continue to advance. From traditional complete downloads to progressive downloads, and now to widely used adaptive bitrate streaming technology, each advancement has significantly enhanced the user experience. This article will explore the implementation of fMP4 (fragmented MP4) technology based on HLS v7, and how it integrates with Media Source Extensions (MSE) in modern Web frontends to create efficient and smooth video playback experiences.
+
+## Evolution of HLS Protocol and Introduction of fMP4
+
+### Traditional HLS and Its Limitations
+
+HTTP Live Streaming (HLS) is an HTTP adaptive bitrate streaming protocol developed by Apple. In earlier versions, HLS primarily used TS (Transport Stream) segments as the media container format. Although the TS format has good error resilience and streaming characteristics, it also has several limitations:
+
+1. Larger file size compared to container formats like MP4
+2. Each TS segment needs to contain complete initialization information, causing redundancy
+3. Lower integration with other parts of the Web technology stack
+
+### HLS v7 and fMP4
+
+HLS v7 introduced support for fMP4 (fragmented MP4) segments, marking a significant advancement in the HLS protocol. As a media container format, fMP4 offers the following advantages over TS:
+
+1. Smaller file size, higher transmission efficiency
+2. Shares the same underlying container format with other streaming protocols like DASH, facilitating a unified technology stack
+3. Better support for modern codecs
+4. Better compatibility with MSE (Media Source Extensions)
+
+In HLS v7, seamless playback of fMP4 segments is achieved by specifying initialization segments using the `#EXT-X-MAP` tag in the playlist.
+
+## MP4 File Structure and fMP4 Basic Principles
+
+### Traditional MP4 Structure
+
+Traditional MP4 files follow the ISO Base Media File Format (ISO BMFF) specification and mainly consist of the following parts:
+
+1. **ftyp** (File Type Box): Indicates the format and compatibility information of the file
+2. **moov** (Movie Box): Contains metadata about the media, such as track information, codec parameters, etc.
+3. **mdat** (Media Data Box): Contains the actual media data
+
+In traditional MP4, the `moov` is usually located at the beginning or end of the file and contains all the metadata and index data for the entire video. This structure is not friendly for streaming transmission because the player needs to acquire the complete `moov` before playback can begin.
+
+Below is a diagram of the MP4 file box structure:
+
+```mermaid
+graph TD
+    MP4[MP4 File] --> FTYP[ftyp box]
+    MP4 --> MOOV[moov box]
+    MP4 --> MDAT[mdat box]
+    MOOV --> MVHD[mvhd: Movie header]
+    MOOV --> TRAK1[trak: Video track]
+    MOOV --> TRAK2[trak: Audio track]
+    TRAK1 --> TKHD1[tkhd: Track header]
+    TRAK1 --> MDIA1[mdia: Media info]
+    TRAK2 --> TKHD2[tkhd: Track header]
+    TRAK2 --> MDIA2[mdia: Media info]
+    MDIA1 --> MDHD1[mdhd: Media header]
+    MDIA1 --> HDLR1[hdlr: Handler]
+    MDIA1 --> MINF1[minf: Media info container]
+    MDIA2 --> MDHD2[mdhd: Media header]
+    MDIA2 --> HDLR2[hdlr: Handler]
+    MDIA2 --> MINF2[minf: Media info container]
+    MINF1 --> STBL1[stbl: Sample table]
+    MINF2 --> STBL2[stbl: Sample table]
+    STBL1 --> STSD1[stsd: Sample description]
+    STBL1 --> STTS1[stts: Time-to-sample]
+    STBL1 --> STSC1[stsc: Sample-to-chunk]
+    STBL1 --> STSZ1[stsz: Sample size]
+    STBL1 --> STCO1[stco: Chunk offset]
+    STBL2 --> STSD2[stsd: Sample description]
+    STBL2 --> STTS2[stts: Time-to-sample]
+    STBL2 --> STSC2[stsc: Sample-to-chunk]
+    STBL2 --> STSZ2[stsz: Sample size]
+    STBL2 --> STCO2[stco: Chunk offset]
+```
+
+### fMP4 Structural Characteristics
+
+fMP4 (fragmented MP4) restructures the traditional MP4 format with the following key features:
+
+1. Divides media data into multiple fragments
+2. Each fragment contains its own metadata and media data
+3. The file structure is more suitable for streaming transmission
+
+The main components of fMP4:
+
+1. **ftyp**: Same as traditional MP4, located at the beginning of the file
+2. **moov**: Contains overall track information, but not specific sample information
+3. **moof** (Movie Fragment Box): Contains metadata for specific fragments
+4. **mdat**: Contains media data associated with the preceding moof
+
+Below is a diagram of the fMP4 file box structure:
+
+```mermaid
+graph TD
+    FMP4[fMP4 File] --> FTYP[ftyp box]
+    FMP4 --> MOOV[moov box]
+    FMP4 --> MOOF1[moof 1: Fragment 1 metadata]
+    FMP4 --> MDAT1[mdat 1: Fragment 1 media data]
+    FMP4 --> MOOF2[moof 2: Fragment 2 metadata]
+    FMP4 --> MDAT2[mdat 2: Fragment 2 media data]
+    FMP4 -.- MOOFN[moof n: Fragment n metadata]
+    FMP4 -.- MDATN[mdat n: Fragment n media data]
+    
+    MOOV --> MVHD[mvhd: Movie header]
+    MOOV --> MVEX[mvex: Movie extends]
+    MOOV --> TRAK1[trak: Video track]
+    MOOV --> TRAK2[trak: Audio track]
+    
+    MVEX --> TREX1[trex 1: Track extends]
+    MVEX --> TREX2[trex 2: Track extends]
+    
+    MOOF1 --> MFHD1[mfhd: Fragment header]
+    MOOF1 --> TRAF1[traf: Track fragment]
+    
+    TRAF1 --> TFHD1[tfhd: Track fragment header]
+    TRAF1 --> TFDT1[tfdt: Track fragment decode time]
+    TRAF1 --> TRUN1[trun: Track run]
+```
+
+This structure allows the player to immediately begin processing subsequent `moof`+`mdat` fragments after receiving the initial `ftyp` and `moov`, making it highly suitable for streaming transmission and real-time playback.
+
+## Conversion Principles from MP4 to fMP4
+
+The MP4 to fMP4 conversion process can be illustrated by the following sequence diagram:
+
+```mermaid
+sequenceDiagram
+    participant MP4 as Source MP4 File
+    participant Demuxer as MP4 Parser
+    participant Muxer as fMP4 Muxer
+    participant fMP4 as Target fMP4 File
+    
+    MP4->>Demuxer: Read MP4 file
+    Note over Demuxer: Parse file structure
+    Demuxer->>Demuxer: Extract ftyp info
+    Demuxer->>Demuxer: Parse moov box
+    Demuxer->>Demuxer: Extract tracks info<br>(video, audio tracks)
+    Demuxer->>Muxer: Pass track metadata
+    
+    Muxer->>fMP4: Write ftyp box
+    Muxer->>Muxer: Create streaming-friendly moov
+    Muxer->>Muxer: Add mvex extension
+    Muxer->>fMP4: Write moov box
+    
+    loop For each media sample
+        Demuxer->>MP4: Read sample data
+        Demuxer->>Muxer: Pass sample
+        Muxer->>Muxer: Create moof box<br>(time and position info)
+        Muxer->>Muxer: Create mdat box<br>(actual media data)
+        Muxer->>fMP4: Write moof+mdat pair
+    end
+    
+    Note over fMP4: Conversion complete
+```
+
+As shown in the diagram, the conversion process consists of three key steps:
+
+1. **Parse the source MP4 file**: Read and parse the structure of the original MP4 file, extract information about video and audio tracks, including codec type, frame rate, resolution, and other metadata.
+
+2. **Create the initialization part of fMP4**: Build the file header and initialization section, including the ftyp and moov boxes. These serve as the initialization segment, containing all the information needed by the decoder, but without actual media sample data.
+
+3. **Create fragments for each sample**: Read the sample data from the original MP4 one by one, then create corresponding moof and mdat box pairs for each sample (or group of samples).
+
+This conversion method transforms MP4 files that were only suitable for download-and-play into fMP4 format suitable for streaming transmission.
+
+## Multiple MP4 Segment Merging Technology
+
+### User Requirement: Time-Range Recording Downloads
+
+In scenarios such as video surveillance, course playback, and live broadcast recording, users often need to download recorded content within a specific time range. For example, a security system operator might only need to export video segments containing specific events, or a student on an educational platform might only want to download key parts of a course. However, since systems typically divide recorded files by fixed durations (e.g., 30 minutes or 1 hour) or specific events (such as the start/end of a live broadcast), the time range needed by users often spans multiple independent MP4 files.
+
+In the Monibuca project, we developed a solution based on time range queries and multi-file merging to address this need. Users only need to specify the start and end times of the content they require, and the system will:
+
+1. Query the database to find all recording files that overlap with the specified time range
+2. Extract relevant time segments from each file
+3. Seamlessly merge these segments into a single downloadable file
+
+This approach greatly enhances the user experience, allowing them to precisely obtain the content they need without having to download and browse through large amounts of irrelevant video content.
+
+### Database Design and Time Range Queries
+
+To support time range queries, our recording file metadata in the database includes the following key fields:
+
+- Stream Path: Identifies the video source
+- Start Time: The start time of the recording segment
+- End Time: The end time of the recording segment
+- File Path: The storage location of the actual recording file
+- Type: The file format, such as "mp4"
+
+When a user requests recordings within a specific time range, the system executes a query similar to the following:
+
+```sql
+SELECT * FROM record_streams 
+WHERE stream_path = ? AND type = 'mp4' 
+AND start_time <= ? AND end_time >= ?
+```
+
+This returns all recording segments that intersect with the requested time range, after which the system needs to extract the relevant parts and merge them.
+
+### Technical Challenges of Multiple MP4 Merging
+
+Merging multiple MP4 files is not a simple file concatenation but requires addressing the following technical challenges:
+
+1. **Timestamp Continuity**: Ensuring that the timestamps in the merged video are continuous, without jumps or overlaps
+2. **Codec Consistency**: Handling cases where different MP4 files may use different encoding parameters
+3. **Metadata Merging**: Correctly merging the moov box information from various files
+4. **Precise Cutting**: Precisely extracting content within the user-specified time range from each file
+
+In practical applications, we implemented two merging strategies: regular MP4 merging and fMP4 merging. These strategies each have their advantages and are suitable for different application scenarios.
+
+### Regular MP4 Merging Process
+
+```mermaid
+sequenceDiagram
+    participant User as User
+    participant API as API Service
+    participant DB as Database
+    participant MP4s as Multiple MP4 Files
+    participant Muxer as MP4 Muxer
+    participant Output as Output MP4 File
+    
+    User->>API: Request time-range recording<br>(stream, startTime, endTime)
+    API->>DB: Query records within specified range
+    DB-->>API: Return matching recording list
+    
+    loop For each MP4 file
+        API->>MP4s: Read file
+        MP4s->>Muxer: Parse file structure
+        Muxer->>Muxer: Parse track info
+        Muxer->>Muxer: Extract media samples
+        Muxer->>Muxer: Adjust timestamps for continuity
+        Muxer->>Muxer: Record sample info and offsets
+        Note over Muxer: Skip samples outside time range
+    end
+    
+    Muxer->>Output: Write ftyp box
+    Muxer->>Output: Write adjusted sample data
+    Muxer->>Muxer: Create moov containing all sample info
+    Muxer->>Output: Write merged moov box
+    Output-->>User: Provide merged file to user
+```
+
+In this approach, the merging process primarily involves arranging media samples from different MP4 files in sequence and adjusting timestamps to ensure continuity. Finally, a new `moov` box containing all sample information is generated. The advantage of this method is its good compatibility, as almost all players can play the merged file normally, making it suitable for download and offline playback scenarios.
+
+It's particularly worth noting that in the code implementation, we handle the overlap relationship between the time range in the parameters and the actual recording time, extracting only the content that users truly need:
+
+```go
+if i == 0 {
+    startTimestamp := startTime.Sub(stream.StartTime).Milliseconds()
+    var startSample *box.Sample
+    if startSample, err = demuxer.SeekTime(uint64(startTimestamp)); err != nil {
+        tsOffset = 0
+        continue
+    }
+    tsOffset = -int64(startSample.Timestamp)
+}
+
+// In the last file, frames beyond the end time are skipped
+if i == streamCount-1 && int64(sample.Timestamp) > endTime.Sub(stream.StartTime).Milliseconds() {
+    break
+}
+```
+
+### fMP4 Merging Process
+
+```mermaid
+sequenceDiagram
+    participant User as User
+    participant API as API Service
+    participant DB as Database
+    participant MP4s as Multiple MP4 Files
+    participant Muxer as fMP4 Muxer
+    participant Output as Output fMP4 File
+    
+    User->>API: Request time-range recording<br>(stream, startTime, endTime)
+    API->>DB: Query records within specified range
+    DB-->>API: Return matching recording list
+    
+    Muxer->>Output: Write ftyp box
+    Muxer->>Output: Write initial moov box<br>(including mvex)
+    
+    loop For each MP4 file
+        API->>MP4s: Read file
+        MP4s->>Muxer: Parse file structure
+        Muxer->>Muxer: Parse track info
+        Muxer->>Muxer: Extract media samples
+        
+        loop For each sample
+            Note over Muxer: Check if sample is within target time range
+            Muxer->>Muxer: Adjust timestamp
+            Muxer->>Muxer: Create moof+mdat pair
+            Muxer->>Output: Write moof+mdat pair
+        end
+    end
+    
+    Output-->>User: Provide merged file to user
+```
+
+The fMP4 merging is more flexible, with each sample packed into an independent `moof`+`mdat` fragment, maintaining independently decodable characteristics, which is more conducive to streaming transmission and random access. This approach is particularly suitable for integration with MSE and HLS, providing support for real-time streaming playback, allowing users to efficiently play merged content directly in the browser without waiting for the entire file to download.
+
+### Handling Codec Compatibility in Merging
+
+In the process of merging multiple recordings, a key challenge we face is handling potential codec parameter differences between files. For example, during long-term recording, a camera might adjust video resolution due to environmental changes, or an encoder might reinitialize, causing changes in encoding parameters.
+
+To solve this problem, Monibuca implements a smart track version management system that identifies changes by comparing encoder-specific data (ExtraData):
+
+```mermaid
+sequenceDiagram
+    participant Muxer as Merger
+    participant Track as Track Manager
+    participant History as Track Version History
+
+    loop For each new track
+        Muxer->>Track: Check track encoding parameters
+        Track->>History: Compare with existing track versions
+        alt Found matching track version
+            History-->>Track: Return existing track
+            Track-->>Muxer: Use existing track
+        else No matching version
+            Track->>Track: Create new track version
+            Track->>History: Add to version history
+            Track-->>Muxer: Use new track
+        end
+    end
+```
+
+This design ensures that even if there are encoding parameter changes in the original recordings, the merged file can maintain correct decoding parameters, providing users with a smooth playback experience.
+
+### Performance Optimization
+
+When processing large video files or a large number of concurrent requests, the performance of the merging process is an important consideration. We have adopted the following optimization measures:
+
+1. **Streaming Processing**: Process samples frame by frame to avoid loading entire files into memory
+2. **Parallel Processing**: Use parallel processing for multiple independent tasks (such as file parsing)
+3. **Smart Caching**: Cache commonly used encoding parameters and file metadata
+4. **On-demand Reading**: Only read and process samples within the target time range
+
+These optimizations enable the system to efficiently process large-scale recording merging requests, completing processing within a reasonable time even for long-term recordings spanning hours or days.
+
+The multiple MP4 merging functionality greatly enhances the flexibility and user experience of Monibuca as a streaming server, allowing users to precisely obtain the recorded content they need, regardless of how the original recordings are segmented and stored.
+
+## Media Source Extensions (MSE) and fMP4 Compatibility Implementation
+
+### MSE Technology Overview
+
+Media Source Extensions (MSE) is a JavaScript API that allows web developers to directly manipulate media stream data. It enables custom adaptive bitrate streaming players to be implemented entirely in the browser without relying on external plugins.
+
+The core working principle of MSE is:
+1. Create a MediaSource object
+2. Create one or more SourceBuffer objects
+3. Append media fragments to the SourceBuffer
+4. The browser is responsible for decoding and playing these fragments
+
+### Perfect Integration of fMP4 with MSE
+
+The fMP4 format has natural compatibility with MSE, mainly reflected in:
+
+1. Each fragment of fMP4 can be independently decoded
+2. The clear separation of initialization segments and media segments conforms to MSE's buffer management model
+3. Precise timestamp control enables seamless splicing
+
+The following sequence diagram shows how fMP4 works with MSE:
+
+```mermaid
+sequenceDiagram
+    participant Client as Browser Client
+    participant Server as Server
+    participant MSE as MediaSource API
+    participant Video as HTML5 Video Element
+    
+    Client->>Video: Create video element
+    Client->>MSE: Create MediaSource object
+    Client->>Video: Set video.src = URL.createObjectURL(mediaSource)
+    MSE-->>Client: sourceopen event
+    
+    Client->>MSE: Create SourceBuffer
+    Client->>Server: Request initialization segment (ftyp+moov)
+    Server-->>Client: Return initialization segment
+    Client->>MSE: appendBuffer(initialization segment)
+    
+    loop During playback
+        Client->>Server: Request media segment (moof+mdat)
+        Server-->>Client: Return media segment
+        Client->>MSE: appendBuffer(media segment)
+        MSE-->>Video: Decode and render frames
+    end
+```
+
+In Monibuca's implementation, we've made special optimizations for MSE: creating independent moof and mdat for each frame. Although this approach adds some overhead, it provides high flexibility, particularly suitable for low-latency real-time streaming scenarios and precise frame-level operations.
+
+## Integration of HLS and fMP4 in Practical Applications
+
+In practical applications, we combine fMP4 technology with the HLS v7 protocol to implement time-range-based on-demand playback. The system can find the corresponding MP4 records from the database based on the time range specified by the user, and then generate an fMP4 format HLS playlist:
+
+```mermaid
+sequenceDiagram
+    participant Client as Client
+    participant Server as HLS Server
+    participant DB as Database
+    participant MP4Plugin as MP4 Plugin
+    
+    Client->>Server: Request fMP4.m3u8<br>with time range parameters
+    Server->>DB: Query MP4 records within specified range
+    DB-->>Server: Return record list
+    
+    Server->>Server: Create HLS v7 playlist<br>Version: 7
+    loop For each record
+        Server->>Server: Calculate duration
+        Server->>Server: Add media segment URL<br>/mp4/download/{stream}.fmp4?id={id}
+    end
+    
+    Server->>Server: Add #EXT-X-ENDLIST marker
+    Server-->>Client: Return HLS playlist
+    
+    loop For each segment
+        Client->>MP4Plugin: Request fMP4 segment
+        MP4Plugin->>MP4Plugin: Convert to fMP4 format
+        MP4Plugin-->>Client: Return fMP4 segment
+    end
+```
+
+Through this approach, we maintain compatibility with existing HLS clients while leveraging the advantages of the fMP4 format to provide more efficient streaming services.
+
+## Conclusion
+
+As a modern media container format, fMP4 combines the efficient compression of MP4 with the flexibility of streaming transmission, making it highly suitable for video distribution needs in modern web applications. Through integration with HLS v7 and MSE technologies, more efficient and flexible streaming services can be achieved.
+
+In the practice of the Monibuca project, we have successfully built a complete streaming solution by implementing MP4 to fMP4 conversion, merging multiple MP4 files, and optimizing fMP4 fragment generation for MSE. The application of these technologies enables our system to provide a better user experience, including faster startup times, smoother quality transitions, and lower bandwidth consumption.
+
+As video technology continues to evolve, fMP4, as a bridge connecting traditional media formats with modern Web technologies, will continue to play an important role in the streaming media field. The Monibuca project will also continue to explore and optimize this technology to provide users with higher quality streaming services. 

doc_CN/arch/admin.md

@@ -0,0 +1,111 @@
+# Admin 服务机制
+
+Monibuca 提供了强大的管理服务支持，用于系统监控、配置管理、插件管理等管理功能。本文档详细说明了 Admin 服务的实现机制和使用方法。
+
+## 服务架构
+
+### 1. UI 界面
+
+Admin 服务通过加载 `admin.zip` 文件来提供 Web 管理界面。该界面具有以下特点：
+
+- 统一的管理界面入口
+- 可调用所有服务器提供的 HTTP 接口
+- 响应式设计，支持多种设备访问
+- 模块化的功能组织
+
+### 2. 配置管理
+
+Admin 服务的配置位于全局配置（global）中的 admin 节，包括：
+
+```yaml
+admin:
+  enableLogin: false    # 是否启用登录机制
+  filePath: admin.zip  # 管理界面文件路径
+  homePage: home      # 管理界面首页
+  users:             # 用户列表（仅在启用登录机制时生效）
+    - username: admin   # 用户名
+      password: admin   # 密码
+      role: admin      # 角色，可选值：admin、user
+```
+
+当 `enableLogin` 为 false 时，所有用户都以匿名用户身份访问。
+当启用登录机制且数据库中没有用户时，系统会自动创建一个默认管理员账户（用户名：admin，密码：admin）。
+
+### 3. 认证机制
+
+Admin 提供专门的用户登录验证接口，用于：
+
+- 用户身份验证
+- 访问令牌管理（JWT）
+- 权限控制
+- 会话管理
+
+### 4. 接口规范
+
+所有的 Admin API 都需要遵循以下规范：
+
+- 响应格式统一包含 code、message、data 字段
+- 成功响应使用 code = 0
+- 错误处理采用统一的错误响应格式
+- 必须进行权限验证
+
+## 功能模块
+
+### 1. 系统监控
+
+- CPU 使用率监控
+- 内存使用情况
+- 网络带宽统计
+- 磁盘使用情况
+- 系统运行时间
+- 在线用户统计
+
+### 2. 插件管理
+
+- 插件启用/禁用
+- 插件配置修改
+- 插件状态查看
+- 插件版本管理
+- 插件依赖检查
+
+### 3. 流媒体管理
+
+- 在线流列表查看
+- 流状态监控
+- 流控制（开始/停止）
+- 流信息统计
+- 录制管理
+- 转码任务管理
+
+## 安全机制
+
+### 1. 认证机制
+
+- JWT 令牌认证
+- 会话超时控制
+- IP 白名单控制
+
+### 2. 权限控制
+
+- 基于角色的访问控制（RBAC）
+- 细粒度的权限管理
+- 操作审计日志
+- 敏感操作确认
+
+## 最佳实践
+
+1. 安全性
+   - 使用 HTTPS 加密
+   - 实施强密码策略
+   - 定期更新密钥
+   - 监控异常访问
+
+2. 性能优化
+   - 合理的缓存策略
+   - 分页查询优化
+   - 异步处理耗时操作
+
+3. 可维护性
+   - 完整的操作日志
+   - 清晰的错误提示
+   - 配置热更新 

doc_CN/arch/alias.md

@@ -0,0 +1,158 @@
+# Monibuca 流别名功能技术实现文档
+
+## 1. 功能概述
+
+流别名（Stream Alias）是 Monibuca 中的一个重要功能，它允许为已存在的流创建一个或多个别名，使得同一个流可以通过不同的路径被访问。这个功能在以下场景特别有用：
+
+- 为长路径的流创建简短别名
+- 动态修改流的访问路径
+- 实现流的重定向功能
+
+## 2. 核心数据结构
+
+### 2.1 AliasStream 结构
+
+```go
+type AliasStream struct {
+    *Publisher      // 继承自 Publisher
+    AutoRemove bool // 是否自动移除
+    StreamPath string // 原始流路径
+    Alias      string // 别名路径
+}
+```
+
+### 2.2 StreamAlias 消息结构
+
+```protobuf
+message StreamAlias {
+    string streamPath = 1;  // 原始流路径
+    string alias = 2;       // 别名
+    bool autoRemove = 3;    // 是否自动移除
+    uint32 status = 4;      // 状态
+}
+```
+
+## 3. 核心功能实现
+
+### 3.1 别名创建和修改
+
+当调用 `SetStreamAlias` API 创建或修改别名时，系统会：
+
+1. 验证并解析目标流路径
+2. 检查目标流是否存在
+3. 处理以下场景：
+   - 修改现有别名：更新自动移除标志和流路径
+   - 创建新别名：初始化新的 AliasStream 结构
+4. 处理订阅者转移或唤醒等待的订阅者
+
+### 3.2 Publisher 启动时的别名处理
+
+当一个 Publisher 启动时，系统会：
+
+1. 检查是否存在指向该 Publisher 的别名
+2. 对于每个匹配的别名：
+   - 如果别名的 Publisher 为空，设置为新的 Publisher
+   - 如果别名已有 Publisher，转移订阅者到新的 Publisher
+3. 唤醒所有等待该流的订阅者
+
+### 3.3 Publisher 销毁时的别名处理
+
+Publisher 销毁时的处理流程：
+
+1. 检查是否因被踢出而停止
+2. 从 Streams 中移除 Publisher
+3. 遍历所有别名，对于指向该 Publisher 的别名：
+   - 如果设置了自动移除，则删除该别名
+   - 否则保留别名结构
+4. 处理相关订阅者
+
+### 3.4 订阅者处理机制
+
+当新的订阅请求到来时：
+
+1. 检查是否存在匹配的别名
+2. 如果存在别名：
+   - 别名对应的 Publisher 存在：添加订阅者
+   - Publisher 不存在：触发 OnSubscribe 事件
+3. 如果不存在别名：
+   - 检查是否有匹配的正则表达式别名
+   - 检查原始流是否存在
+   - 根据情况添加订阅者或加入等待列表
+
+## 4. API 接口
+
+### 4.1 设置别名
+
+```http
+POST /api/stream/alias
+```
+
+请求体：
+```json
+{
+    "streamPath": "原始流路径",
+    "alias": "别名路径",
+    "autoRemove": false
+}
+```
+
+### 4.2 获取别名列表
+
+```http
+GET /api/stream/alias
+```
+
+响应体：
+```json
+{
+    "code": 0,
+    "message": "",
+    "data": [
+        {
+            "streamPath": "原始流路径",
+            "alias": "别名路径",
+            "autoRemove": false,
+            "status": 1
+        }
+    ]
+}
+```
+
+## 5. 状态说明
+
+别名状态（status）说明：
+- 0：初始状态
+- 1：别名已关联 Publisher
+- 2：存在同名的原始流
+
+## 6. 最佳实践
+
+1. 使用自动移除（autoRemove）
+   - 当需要临时重定向流时，建议启用自动移除
+   - 这样在原始流结束时，别名会自动清理
+
+2. 别名命名建议
+   - 使用简短且有意义的别名
+   - 避免使用特殊字符
+   - 建议使用规范的路径格式
+
+3. 性能考虑
+   - 别名机制采用高效的内存映射
+   - 订阅者转移时保持连接状态
+   - 支持动态修改，无需重启服务
+
+## 7. 注意事项
+
+1. 别名冲突处理
+   - 当创建的别名与现有流路径冲突时，系统会进行适当处理
+   - 建议在创建别名前检查是否存在冲突
+
+2. 订阅者行为
+   - 别名修改时，现有订阅者会被转移到新的流
+   - 确保客户端能够处理流重定向
+
+3. 资源管理
+   - 及时清理不需要的别名
+   - 合理使用自动移除功能
+   - 监控别名状态，避免资源泄露
+``` 

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验证失败

doc_CN/arch/catalog.md

@@ -0,0 +1,77 @@
+# 目录结构说明
+```bash
+monibuca/
+├── api.go               # API接口定义
+├── plugin.go            # 插件系统核心实现
+├── publisher.go         # 发布者实现
+├── subscriber.go        # 订阅者实现
+├── server.go            # 服务器核心实现
+├── puller.go           # 拉流器实现
+├── pusher.go           # 推流器实现
+├── pull-proxy.go       # 拉流代理实现
+├── push-proxy.go       # 推流代理实现
+├── recoder.go          # 录制器实现
+├── transformer.go      # 转码器实现
+├── wait-stream.go      # 流等待实现
+├── prometheus.go       # Prometheus监控实现
+│
+├── pkg/                # 核心包
+│   ├── auth/          # 认证相关
+│   ├── codec/         # 编解码实现
+│   ├── config/        # 配置相关
+│   ├── db/            # 数据库相关
+│   ├── task/          # 任务系统
+│   ├── util/          # 工具函数
+│   ├── filerotate/    # 文件轮转管理
+│   ├── log.go         # 日志实现
+│   ├── raw.go         # 原始数据处理
+│   ├── error.go       # 错误处理
+│   ├── track.go       # 媒体轨道实现
+│   ├── track_test.go  # 媒体轨道测试
+│   ├── annexb.go      # H.264/H.265 Annex-B格式处理
+│   ├── av-reader.go   # 音视频读取器
+│   ├── avframe.go     # 音视频帧结构
+│   ├── ring-writer.go # 环形缓冲区写入器
+│   ├── ring-reader.go # 环形缓冲区读取器
+│   ├── adts.go        # AAC-ADTS格式处理
+│   ├── port.go        # 端口管理
+│   ├── ring_test.go   # 环形缓冲区测试
+│   └── event.go       # 事件系统
+│
+├── plugin/            # 插件目录
+│   ├── rtmp/         # RTMP协议插件
+│   ├── rtsp/         # RTSP协议插件
+│   ├── hls/          # HLS协议插件
+│   ├── flv/          # FLV协议插件
+│   ├── webrtc/       # WebRTC协议插件
+│   ├── gb28181/      # GB28181协议插件
+│   ├── onvif/        # ONVIF协议插件
+│   ├── mp4/          # MP4相关插件
+│   ├── room/         # 房间管理插件
+│   ├── monitor/      # 监控插件
+│   ├── rtp/          # RTP协议插件
+│   ├── srt/          # SRT协议插件
+│   ├── sei/          # SEI数据处理插件
+│   ├── snap/         # 截图插件
+│   ├── crypto/       # 加密插件
+│   ├── debug/        # 调试插件
+│   ├── cascade/      # 级联插件
+│   ├── logrotate/    # 日志轮转插件
+│   ├── test/         # 测试插件（包含压力测试功能）
+│   ├── vmlog/        # 虚拟内存日志插件
+│   ├── preview/      # 预览插件
+│   └── transcode/    # 转码插件
+│
+├── pb/               # Protocol Buffers定义和生成的代码
+├── scripts/          # 脚本文件
+├── doc/             # 英文文档
+├── doc_CN/          # 中文文档
+├── example/         # 示例代码
+├── test/            # 测试代码
+├── website/         # 网站前端代码
+│
+├── go.mod           # Go模块定义
+├── go.sum           # Go依赖版本锁定
+├── Dockerfile       # Docker构建文件
+└── README.md        # 项目说明文档
+```

doc_CN/arch/config.md

@@ -0,0 +1,291 @@
+# Monibuca 配置机制
+
+Monibuca 采用灵活的配置机制，支持多种配置方式。配置文件采用 YAML 格式，可以通过文件或者直接传入配置对象的方式进行初始化。
+
+## 配置加载流程
+
+1. 配置初始化发生在 Server 启动阶段，通过以下三种方式之一提供配置：
+   - YAML 配置文件路径
+   - YAML 配置内容的字节数组
+   - 原始配置对象 (RawConfig)
+
+2. 配置解析过程：
+   ```go
+   // 支持三种配置输入方式
+   case string:  // 配置文件路径
+   case []byte:  // YAML 配置内容
+   case RawConfig:  // 原始配置对象
+   ```
+
+## 配置结构
+
+### 配置简化语法
+
+当配置项的值是一个结构体或 map 类型时，系统支持一种简化的配置方式：如果直接配置一个简单类型的值，该值会被自动赋给结构体的第一个字段。
+
+例如，对于以下结构体：
+```go
+type Config struct {
+    Port int
+    Host string
+}
+```
+
+可以使用简化语法：
+```yaml
+plugin: 1935  # 等同于 plugin: { port: 1935 }
+```
+
+### 配置反序列化机制
+
+每个插件都包含一个 `config.Config` 类型的字段，用于存储和管理配置信息。配置加载的优先级从高到低是：
+
+1. 用户配置 (通过 `ParseUserFile`)
+2. 默认配置 (通过 `ParseDefaultYaml`)
+3. 全局配置 (通过 `ParseGlobal`)
+4. 插件特定配置 (通过 `Parse`)
+5. 通用配置 (通过 `Parse`)
+
+配置会被自动反序列化到插件的公开属性中。例如：
+
+```go
+type MyPlugin struct {
+    Plugin
+    Port    int    `yaml:"port"`
+    Host    string `yaml:"host"`
+}
+```
+
+对应的 YAML 配置：
+```yaml
+myplugin:
+    port: 8080
+    host: "localhost"
+```
+
+配置会自动反序列化到 `Port` 和 `Host` 字段中。你可以通过 `Config` 提供的方法来查询配置：
+- `Has(name string)` - 检查是否存在某个配置
+- `Get(name string)` - 获取某个配置的值
+- `GetMap()` - 获取所有配置的 map
+
+此外，插件的配置支持保存修改：
+```go
+func (p *Plugin) SaveConfig() (err error)
+```
+这会将修改后的配置保存到 `{settingDir}/{pluginName}.yaml` 文件中。
+
+### 全局配置
+
+全局配置位于 YAML 文件的 `global` 节点下，包含以下主要配置项：
+
+```yaml
+global:
+  settingDir: ".m7s"        # 设置文件目录
+  fatalDir: "fatal"         # 错误日志目录
+  pulseInterval: "5s"       # 心跳间隔
+  disableAll: false         # 是否禁用所有插件
+  streamAlias:              # 流别名配置
+    pattern: "target"       # 正则表达式 -> 目标路径
+  location:                 # HTTP 路由转发规则
+    pattern: "target"       # 正则表达式 -> 目标地址
+  admin:                    # 管理界面配置
+    enableLogin: false      # 是否启用登录机制
+    filePath: "admin.zip"   # 管理界面文件路径
+    homePage: "home"        # 管理界面首页
+    users:                  # 用户列表(仅在启用登录时生效)
+      - username: "admin"   # 用户名
+        password: "admin"   # 密码
+        role: "admin"       # 角色(admin/user)
+```
+
+### 数据库配置
+
+如果配置了数据库连接，系统会自动进行以下操作：
+
+1. 连接数据库
+2. 自动迁移数据模型
+3. 初始化用户数据（如果启用了登录机制）
+4. 初始化代理配置
+
+```yaml
+global:
+  db:
+    dsn: ""                # 数据库连接字符串
+    type: ""              # 数据库类型
+```
+
+### 代理配置
+
+系统支持拉流代理和推流代理配置：
+
+```yaml
+global:
+  pullProxy:              # 拉流代理配置
+    - id: 1              # 代理ID
+      name: "proxy1"     # 代理名称
+      url: "rtmp://..."  # 代理地址
+      type: "rtmp"       # 代理类型
+      pullOnStart: true  # 是否启动时拉流
+
+  pushProxy:              # 推流代理配置
+    - id: 1              # 代理ID
+      name: "proxy1"     # 代理名称
+      url: "rtmp://..."  # 代理地址
+      type: "rtmp"       # 代理类型
+      pushOnStart: true  # 是否启动时推流
+      audio: true        # 是否推送音频
+```
+
+## 插件配置
+
+每个插件可以有自己的配置节点，节点名为插件名称的小写形式：
+
+```yaml
+rtmp:                    # RTMP插件配置
+  port: 1935            # 监听端口
+
+rtsp:                   # RTSP插件配置
+  port: 554             # 监听端口
+```
+
+## 配置优先级
+
+配置系统采用多级优先级机制，从高到低依次为：
+
+1. URL 查询参数配置 - 发布或订阅时通过 URL 查询参数指定的配置具有最高优先级
+   ```
+   例如：rtmp://localhost/live/stream?audio=false
+   ```
+
+2. 插件特定配置 - 在插件配置节点下的配置项
+   ```yaml
+   rtmp:
+     publish:
+       audio: true
+     subscribe:
+       audio: true
+   ```
+
+3. 全局配置 - 在 global 节点下的配置项
+   ```yaml
+   global:
+     publish:
+       audio: true
+     subscribe:
+       audio: true
+   ```
+
+## 通用配置
+
+系统中存在一些通用配置项，这些配置项可以同时出现在全局配置和插件配置中。当插件使用这些配置项时，会优先使用插件配置中的值，如果插件配置中没有设置，则使用全局配置中的值。
+
+主要的通用配置包括：
+
+1. 发布配置（Publish）
+   ```yaml
+   publish:
+     audio: true          # 是否包含音频
+     video: true          # 是否包含视频
+     bufferLength: 1000   # 缓冲长度
+   ```
+
+2. 订阅配置（Subscribe）
+   ```yaml
+   subscribe:
+     audio: true          # 是否订阅音频
+     video: true          # 是否订阅视频
+     bufferLength: 1000   # 缓冲长度
+   ```
+
+3. HTTP 配置
+   ```yaml
+   http:
+     listenAddr: ":8080"  # 监听地址
+   ```
+
+4. 其他通用配置
+   - PublicIP - 公网 IP
+   - PublicIPv6 - 公网 IPv6
+   - LogLevel - 日志级别
+   - EnableAuth - 是否启用认证
+
+使用示例：
+
+```yaml
+# 全局配置
+global:
+  publish:
+    audio: true
+    video: true
+  subscribe:
+    audio: true
+    video: true
+
+# 插件配置（优先级高于全局配置）
+rtmp:
+  publish:
+    audio: false  # 覆盖全局配置
+  subscribe:
+    video: false  # 覆盖全局配置
+
+# URL 查询参数（最高优先级）
+# rtmp://localhost/live/stream?audio=true&video=false
+```
+
+## 配置热更新
+
+目前系统支持管理界面文件（admin.zip）的热更新，会定期检查文件变化并自动重新加载。
+
+## 配置验证
+
+系统在启动时会对配置进行基本验证：
+
+1. 检查必要的目录权限
+2. 验证数据库连接
+3. 验证用户配置（如果启用登录机制）
+
+## 配置示例
+
+完整的配置文件示例：
+
+```yaml
+global:
+  settingDir: ".m7s"
+  fatalDir: "fatal"
+  pulseInterval: "5s"
+  disableAll: false
+  streamAlias:
+    "live/(.*)": "record/$1"
+  location:
+    "^/live/(.*)": "/hls/$1"
+  admin:
+    enableLogin: true
+    filePath: "admin.zip"
+    homePage: "home"
+    users:
+      - username: "admin"
+        password: "admin"
+        role: "admin"
+  db:
+    dsn: "host=localhost user=postgres password=postgres dbname=monibuca port=5432 sslmode=disable TimeZone=Asia/Shanghai"
+    type: "postgres"
+  pullProxy:
+    - id: 1
+      name: "proxy1"
+      url: "rtmp://example.com/live/stream"
+      type: "rtmp"
+      pullOnStart: true
+  pushProxy:
+    - id: 1
+      name: "proxy1"
+      url: "rtmp://example.com/live/stream"
+      type: "rtmp"
+      pushOnStart: true
+      audio: true
+
+rtmp:
+  port: 1935
+
+rtsp:
+  port: 554
+```

doc_CN/arch/db.md

@@ -0,0 +1,94 @@
+# 数据库机制
+
+Monibuca 提供了数据库支持功能，可以在全局配置和插件中分别配置和使用数据库。
+
+## 配置说明
+
+### 全局配置
+
+在全局配置中可以通过以下字段配置数据库：
+
+```yaml
+global:
+  dsn: "数据库连接字符串"
+  dbType: "数据库类型"
+```
+
+### 插件配置
+
+每个插件也可以单独配置数据库：
+
+```yaml
+pluginName:
+  dsn: "数据库连接字符串"
+  dbType: "数据库类型"
+```
+
+## 数据库初始化流程
+
+### 全局数据库初始化
+
+1. 服务器启动时，如果配置了 `dsn`，会尝试连接数据库
+2. 连接成功后会自动迁移以下模型:
+   - User 用户表
+   - PullProxy 拉流代理表
+   - PushProxy 推流代理表
+   - StreamAliasDB 流别名表
+
+3. 如果开启了登录功能(`Admin.EnableLogin = true`)，会根据配置文件创建或更新用户
+4. 如果数据库中没有任何用户，会创建一个默认的管理员账户:
+   - 用户名: admin
+   - 密码: admin
+   - 角色: admin
+
+### 插件数据库初始化
+
+1. 插件初始化时会检查插件配置中的 `dsn`
+2. 如果插件配置的 `dsn` 与全局配置相同，则直接使用全局数据库连接
+3. 如果插件配置了不同的 `dsn`，则会创建新的数据库连接
+4. 如果插件实现了 Recorder 接口，会自动迁移 RecordStream 表
+
+## 数据库使用
+
+### 全局数据库访问
+
+可以通过 Server 实例访问全局数据库:
+
+```go
+server.DB
+```
+
+### 插件数据库访问
+
+插件可以通过自身实例访问数据库:
+
+```go
+plugin.DB
+```
+
+## 注意事项
+
+1. 数据库连接失败会导致相应的功能被禁用
+2. 插件使用独立数据库时需要自行管理数据库连接
+3. 数据库迁移失败会导致插件被禁用
+4. 建议在可能的情况下复用全局数据库连接，避免创建过多连接
+
+## 内置数据表
+
+### User 表
+用于存储用户信息，包含以下字段:
+- Username: 用户名
+- Password: 密码
+- Role: 角色(admin/user)
+
+### PullProxy 表
+用于存储拉流代理配置
+
+### PushProxy 表
+用于存储推流代理配置
+
+### StreamAliasDB 表
+用于存储流别名配置
+
+### RecordStream 表
+用于存储录制相关信息(仅在插件实现 Recorder 接口时创建)

doc_CN/arch/grpc.md

@@ -0,0 +1,72 @@
+# GRPC 服务机制
+
+Monibuca 提供了 gRPC 服务支持，允许插件通过 gRPC 协议提供服务。本文档说明了 gRPC 服务的实现机制和使用方法。
+
+## 服务注册机制
+
+### 1. 服务注册
+
+插件注册 gRPC 服务需要在 `InstallPlugin` 时传入 ServiceDesc 和 Handler：
+
+```go
+// 示例：在插件中注册 gRPC 服务
+type MyPlugin struct {
+    pb.UnimplementedApiServer
+    m7s.Plugin
+}
+
+var _ = m7s.InstallPlugin[MyPlugin](
+    m7s.DefaultYaml(`your yaml config here`),
+    &pb.Api_ServiceDesc,           // gRPC service descriptor
+    pb.RegisterApiHandler,         // gRPC gateway handler
+    // ... 其他参数
+)
+```
+
+### 2. Proto 文件规范
+
+所有的 gRPC 服务都需要遵循以下 Proto 文件规范：
+
+- 响应结构体必须包含 code、message、data 字段
+- 错误处理采用直接返回 error 的方式，无需手动设置 code 和 message
+- 修改 global.proto 后需要运行 `sh scripts/protoc.sh` 生成 pb 文件
+- 修改插件相关的 proto 文件后需要运行 `sh scripts/protoc.sh {pluginName}` 生成对应的 pb 文件
+
+## 服务实现机制
+
+### 1. 服务器配置
+
+gRPC 服务使用全局 TCP 配置中的端口设置：
+
+```yaml
+global:
+  tcp:
+    listenaddr: :8080     # gRPC 服务监听地址和端口
+    listentls: :8443      # gRPC TLS 服务监听地址和端口（如果启用）
+```
+
+配置项包括：
+- 监听地址和端口设置（在全局 TCP 配置中指定）
+- TLS/SSL 证书配置（如果启用）
+
+### 2. 错误处理
+
+错误处理遵循以下原则：
+
+- 直接返回 error，无需手动设置 code 和 message
+- 系统会自动处理错误并设置响应格式
+
+## 最佳实践
+
+1. 服务定义
+   - 清晰的服务接口设计
+   - 合理的方法命名
+   - 完整的接口文档
+
+2. 性能优化
+   - 使用流式处理大数据
+   - 合理设置超时时间
+
+3. 安全考虑
+   - 根据需要启用 TLS 加密
+   - 实现必要的访问控制 

doc_CN/arch/http.md

@@ -0,0 +1,145 @@
+# HTTP 服务机制
+
+Monibuca 提供了完整的 HTTP 服务支持，包括 RESTful API、WebSocket、HTTP-FLV 等多种协议支持。本文档详细说明了 HTTP 服务的实现机制和使用方法。
+
+## HTTP 配置
+
+### 1. 配置优先级
+
+- 插件的 HTTP 配置优先于全局 HTTP 配置
+- 如果插件没有配置 HTTP，则使用全局 HTTP 配置
+
+### 2. 配置项说明
+
+```yaml
+# 全局配置示例
+global:
+  http:
+    listenaddr: :8080  # 监听地址和端口
+    listentlsaddr: :8081 # 监听tls地址和端口
+    certfile: ""       # SSL证书文件路径
+    keyfile: ""        # SSL密钥文件路径
+    cors: true        # 是否允许跨域
+    username: ""      # Basic认证用户名
+    password: ""      # Basic认证密码
+
+# 插件配置示例（优先于全局配置）
+plugin_name:
+  http:
+    listenaddr: :8081
+    cors: false
+    username: "admin"
+    password: "123456"
+```
+
+## 服务处理流程
+
+### 1. 请求处理顺序
+
+HTTP 服务器接收到请求后，按以下顺序处理：
+
+1. 首先尝试转发到对应的 gRPC 服务
+2. 如果没有找到对应的 gRPC 服务，则查找插件注册的 HTTP handler
+3. 如果都没有找到，返回 404 错误
+
+### 2. Handler 注册方式
+
+插件可以通过以下两种方式注册 HTTP handler：
+
+1. 反射注册：系统自动通过反射获取插件的处理方法
+   - 方法名必须大写开头才能被反射获取（Go 语言规则）
+   - 通常使用 `API_` 作为方法名前缀（推荐但不强制）
+   - 方法签名必须为 `func(w http.ResponseWriter, r *http.Request)`
+   - URL 路径自动生成规则：
+     - 方法名中的下划线 `_` 会被转换为斜杠 `/`
+     - 例如：`API_relay_` 方法将映射到 `/API/relay/*` 路径
+   - 如果方法名以下划线结尾，表示这是一个通配符路径，可以匹配后续任意路径
+
+2. 手动注册：插件实现 `IRegisterHandler` 接口进行手动注册
+   - 小写开头的方法无法被反射获取，需要通过手动注册方式
+   - 手动注册可以使用路径参数（如 `:id`）
+   - 更灵活的路由规则配置
+
+示例代码：
+```go
+// 反射注册示例
+type YourPlugin struct {
+    // ...
+}
+
+// 大写开头，可以被反射获取
+// 自动映射到 /API/relay/*
+func (p *YourPlugin) API_relay_(w http.ResponseWriter, r *http.Request) {
+    // 处理通配符路径的请求
+}
+
+// 小写开头，无法被反射获取，需要手动注册
+func (p *YourPlugin) handleUserRequest(w http.ResponseWriter, r *http.Request) {
+    // 处理带参数的请求
+}
+
+// 手动注册示例
+func (p *YourPlugin) RegisterHandler() {
+    // 可以使用路径参数
+    engine.GET("/api/user/:id", p.handleUserRequest)
+}
+```
+
+## 中间件机制
+
+### 1. 添加中间件
+
+插件可以通过 `AddMiddleware` 方法添加全局中间件，用于处理所有 HTTP 请求。中间件按照添加顺序依次执行。
+
+示例代码：
+```go
+func (p *YourPlugin) Start() {
+    // 添加认证中间件
+    p.GetCommonConf().AddMiddleware(func(next http.HandlerFunc) http.HandlerFunc {
+        return func(w http.ResponseWriter, r *http.Request) {
+            // 在请求处理前执行
+            if !authenticate(r) {
+                http.Error(w, "Unauthorized", http.StatusUnauthorized)
+                return
+            }
+            // 调用下一个处理器
+            next(w, r)
+            // 在请求处理后执行
+        }
+    })
+}
+```
+
+### 2. 中间件使用场景
+
+- 认证和授权
+- 请求日志记录
+- CORS 处理
+- 请求限流
+- 响应头设置
+- 错误处理
+- 性能监控
+
+## 特殊协议支持
+
+### 1. HTTP-FLV
+
+- 支持 HTTP-FLV 直播流分发
+- 自动生成 FLV 头
+- 支持 GOP 缓存
+- 支持 WebSocket-FLV
+
+### 2. HTTP-MP4
+
+- 支持 HTTP-MP4 流分发
+- 支持 fMP4 文件分发
+
+### 3. HLS
+- 支持 HLS 协议
+- 支持 MPEG-TS 封装
+
+### 4. WebSocket
+
+- 支持自定义消息协议
+- 支持ws-flv
+- 支持ws-mp4

doc_CN/arch/index.md

@@ -0,0 +1,57 @@
+# 架构设计
+
+## 目录结构
+
+[catalog.md](./catalog.md)
+
+## 音视频流系统
+
+### 转发机制
+
+[relay.md](./relay.md)
+
+### 别名机制
+
+[alias.md](./alias.md)
+
+### 鉴权机制
+
+[auth.md](./auth.md)
+
+## 插件系统
+
+### 生命周期
+
+[plugin.md](./plugin.md)
+
+### 开发插件
+
+[plugin/README_CN.md](../plugin/README_CN.md)
+
+## 任务系统
+
+[task.md](./task.md)
+
+## 配置机制
+
+[config.md](./config.md)
+
+## 日志系统
+
+[log.md](./log.md)
+
+## 数据库机制
+
+[db.md](./db.md)
+
+## GRPC 服务
+
+[grpc.md](./grpc.md)
+
+## HTTP 服务
+
+[http.md](./http.md)
+
+## Admin 服务
+
+[admin.md](./admin.md)

doc_CN/arch/log.md

@@ -0,0 +1,124 @@
+# 日志机制
+
+Monibuca 使用 Go 标准库的 `slog` 作为日志系统，提供了结构化的日志记录功能。
+
+## 日志配置
+
+在全局配置中，可以通过 `LogLevel` 字段来设置日志级别。支持的日志级别有：
+
+- trace
+- debug
+- info 
+- warn
+- error
+
+配置示例:
+
+```yaml
+global:
+  LogLevel: "debug" # 设置日志级别为 debug
+```
+
+## 日志格式
+
+默认的日志格式包含以下信息：
+
+- 时间戳 (格式: HH:MM:SS.MICROSECONDS)
+- 日志级别
+- 日志消息
+- 结构化字段
+
+示例输出:
+```
+15:04:05.123456 INFO server started
+15:04:05.123456 ERROR failed to connect database dsn="xxx" type="mysql"
+```
+
+## 日志处理器
+
+Monibuca 使用 `console-slog` 作为默认的日志处理器，它提供了:
+
+1. 彩色输出支持
+2. 微秒级时间戳
+3. 结构化字段格式化
+
+### 多处理器支持
+
+Monibuca 实现了 `MultiLogHandler` 机制，支持同时使用多个日志处理器。这提供了以下优势：
+
+1. 可以同时将日志输出到多个目标（如控制台、文件、日志服务等）
+2. 支持动态添加和移除日志处理器
+3. 每个处理器可以有自己的日志级别设置
+4. 支持日志分组和属性继承
+
+通过插件系统，可以扩展多种日志处理方式，例如：
+
+- LogRotate 插件：支持日志文件轮转
+- VMLog 插件：支持将日志存储到 VictoriaMetrics 时序数据库
+
+## 在插件中使用日志
+
+每个插件都会继承服务器的日志配置。插件可以通过以下方式记录日志：
+
+```go
+plugin.Info("message", "key1", value1, "key2", value2)  // 记录 INFO 级别日志
+plugin.Debug("message", "key1", value1)                 // 记录 DEBUG 级别日志
+plugin.Warn("message", "key1", value1)                  // 记录 WARN 级别日志
+plugin.Error("message", "key1", value1)                 // 记录 ERROR 级别日志
+```
+
+## 日志初始化流程
+
+1. 服务器启动时创建默认的控制台日志处理器
+2. 从配置文件读取日志级别设置
+3. 应用日志级别配置
+4. 为每个插件设置继承的日志配置
+
+## 最佳实践
+
+1. 合理使用日志级别
+   - trace: 用于最详细的追踪信息
+   - debug: 用于调试信息
+   - info: 用于正常运行时的重要信息
+   - warn: 用于警告信息
+   - error: 用于错误信息
+
+2. 使用结构化字段
+   - 避免在消息中拼接变量
+   - 使用 key-value 对记录额外信息
+
+3. 错误处理
+   - 记录错误时包含完整的错误信息
+   - 添加相关的上下文信息
+
+示例:
+```go
+// 推荐
+s.Error("failed to connect database", "error", err, "dsn", dsn)
+
+// 不推荐
+s.Error("failed to connect database: " + err.Error())
+```
+
+## 扩展日志系统
+
+要扩展日志系统，可以通过以下方式：
+
+1. 实现自定义的 `slog.Handler` 接口
+2. 使用 `LogHandler.Add()` 方法添加新的处理器
+3. 可以通过插件系统提供更复杂的日志功能
+
+例如添加自定义日志处理器：
+
+```go
+type MyLogHandler struct {
+    slog.Handler
+}
+
+// 在插件初始化时添加处理器
+func (p *MyPlugin) Start() error {
+    handler := &MyLogHandler{}
+    p.Server.LogHandler.Add(handler)
+    return nil
+}
+```

doc_CN/arch/plugin.md

@@ -0,0 +1,170 @@
+# 插件系统
+
+Monibuca 采用插件化架构设计，通过插件机制来扩展功能。插件系统是 Monibuca 的核心特性之一，它允许开发者以模块化的方式添加新功能，而不需要修改核心代码。
+
+## 插件生命周期
+
+插件系统具有完整的生命周期管理，主要包含以下阶段：
+
+### 1. 注册阶段
+
+插件通过 `InstallPlugin` 泛型函数进行注册，在此阶段会：
+
+- 创建插件元数据(PluginMeta)，包含：
+  - 插件名称：自动从插件结构体名称中提取(去除"Plugin"后缀)
+  - 插件版本：从调用者的文件路径或包路径中提取，如果无法提取则默认为"dev"
+  - 插件类型：通过反射获取插件结构体类型
+  
+- 注册可选功能：
+  - 退出处理器(OnExitHandler)
+  - 默认配置(DefaultYaml)
+  - 拉流器(Puller)
+  - 推流器(Pusher)
+  - 录制器(Recorder)
+  - 转换器(Transformer)
+  - 发布认证(AuthPublisher)
+  - 订阅认证(AuthSubscriber)
+  - gRPC服务(ServiceDesc)
+  - gRPC网关处理器(RegisterGRPCHandler)
+
+- 将插件元数据添加到全局插件列表中
+
+注册阶段是插件生命周期的第一个阶段，它为插件系统提供了插件的基本信息和功能定义，为后续的初始化和启动做准备。
+
+### 2. 初始化阶段 (Init)
+
+插件通过 `Plugin.Init` 方法进行初始化，此阶段包含以下步骤：
+
+1. 实例化检查
+   - 检查插件是否实现了 IPlugin 接口
+   - 通过反射获取插件实例
+
+2. 基础设置
+   - 设置插件元数据和服务器引用
+   - 配置插件日志记录器
+   - 设置插件名称和版本信息
+
+3. 环境检查
+   - 检查环境变量是否禁用插件(通过 {PLUGIN_NAME}_ENABLE=false)
+   - 检查全局禁用状态(DisableAll)
+   - 检查用户配置中的启用状态(enable)
+
+4. 配置加载
+   - 解析通用配置
+   - 加载默认YAML配置
+   - 合并用户配置
+   - 应用最终配置并记录
+
+5. 数据库初始化（如果需要）
+   - 检查数据库连接配置(DSN)
+   - 建立数据库连接
+   - 自动迁移数据库表结构(针对录制功能)
+
+6. 状态记录
+   - 记录插件版本
+   - 记录用户配置
+   - 设置日志级别
+   - 记录初始化状态
+
+如果在初始化过程中发生错误：
+- 插件将被标记为禁用状态
+- 记录禁用原因
+- 添加到已禁用插件列表
+
+初始化阶段为插件的运行准备必要的环境和资源，是确保插件正常运行的关键阶段。
+
+### 3. 启动阶段 (Start)
+
+插件通过 `Plugin.Start` 方法启动，此阶段按顺序执行以下操作：
+
+1. gRPC服务注册（如果配置）
+   - 注册gRPC服务
+   - 注册gRPC网关处理器
+   - 处理gRPC相关错误
+
+2. 插件管理
+   - 将插件添加到服务器的插件列表中
+   - 设置插件状态为运行中
+
+3. 网络监听初始化
+   - HTTP/HTTPS服务启动
+   - TCP/TLS服务启动（如果实现了ITCPPlugin接口）
+   - UDP服务启动（如果实现了IUDPPlugin接口）
+   - QUIC服务启动（如果实现了IQUICPlugin接口）
+
+4. 插件初始化回调
+   - 调用插件的OnInit方法
+   - 处理初始化错误
+
+5. 定时任务设置
+   - 配置服务器保活任务（如果启用）
+   - 设置其他定时任务
+
+如果在启动过程中发生错误：
+- 记录错误原因
+- 将插件标记为禁用状态
+- 停止后续启动步骤
+
+启动阶段是插件开始提供服务的关键阶段，此时插件完成了所有准备工作，可以开始处理业务逻辑。
+
+### 4. 停止阶段 (Stop)
+
+插件的停止阶段通过 `Plugin.OnDispose` 方法和相关的停止处理逻辑实现，主要包含以下步骤：
+
+1. 停止服务
+   - 停止所有网络服务（HTTP/HTTPS/TCP/UDP/QUIC）
+   - 关闭所有网络连接
+   - 停止处理新的请求
+
+2. 资源清理
+   - 停止所有定时任务
+   - 关闭数据库连接（如果有）
+   - 清理临时文件和缓存
+
+3. 状态处理
+   - 更新插件状态为已停止
+   - 从服务器的活动插件列表中移除
+   - 触发停止事件通知
+
+4. 回调处理
+   - 调用插件自定义的OnStop方法
+   - 执行注册的停止回调函数
+   - 处理停止过程中的错误
+
+5. 连接处理
+   - 等待当前请求处理完成
+   - 优雅关闭现有连接
+   - 拒绝新的连接请求
+
+停止阶段的主要目标是确保插件能够安全、干净地停止运行，不影响系统的其他部分。
+
+### 5. 销毁阶段 (Destroy)
+
+插件的销毁阶段通过 `Plugin.Dispose` 方法实现，这是插件生命周期的最后阶段，主要包含以下步骤：
+
+1. 资源释放
+   - 调用插件的OnStop方法进行停止处理
+   - 从服务器的插件列表中移除
+   - 释放所有分配的系统资源
+
+2. 状态清理
+   - 清除插件的所有状态信息
+   - 重置插件的内部变量
+   - 清空插件的配置信息
+
+3. 连接断开
+   - 断开与其他插件的所有连接
+   - 清理插件间的依赖关系
+   - 移除事件监听器
+
+4. 数据清理
+   - 清理插件产生的临时数据
+   - 关闭并清理数据库连接
+   - 删除不再需要的文件
+
+5. 最终处理
+   - 执行注册的销毁回调函数
+   - 记录销毁日志
+   - 确保所有资源都被正确释放
+
+销毁阶段的主要目标是确保插件完全清理所有资源，不留下任何残留状态，防止内存泄漏和资源泄露。

doc_CN/arch/reader_design_philosophy.md

@@ -0,0 +1,146 @@
+# 贯彻 Go 语言 Reader 接口设计哲学：以 Monibuca 中的流媒体处理为例
+
+## 引言
+
+Go 语言以其简洁、高效和并发安全的设计哲学而闻名，其中 io.Reader 接口是这一哲学的典型体现。在实际业务开发中，如何正确运用 io.Reader 接口的设计思想，对于构建高质量、可维护的系统至关重要。本文将以 Monibuca 流媒体服务器中的 RTP 数据处理为例，深入探讨如何在实际业务中贯彻 Go 语言的 Reader 接口设计哲学，包括同步编程模式、单一职责原则、关注点分离以及组合复用等核心概念。
+
+## 什么是 Go 语言的 Reader 接口设计哲学？
+
+Go 语言的 io.Reader 接口设计哲学主要体现在以下几个方面：
+
+1. **简单性**：io.Reader 接口只定义了一个方法 `Read(p []byte) (n int, err error)`，这种极简设计使得任何实现了该方法的类型都可以被视为一个 Reader。
+
+2. **组合性**：通过组合不同的 Reader，可以构建出功能强大的数据处理管道。
+
+3. **单一职责**：每个 Reader 只负责一个特定的任务，符合单一职责原则。
+
+4. **关注点分离**：不同的 Reader 负责处理不同的数据格式或协议，实现了关注点的分离。
+
+## Monibuca 中的 Reader 设计实践
+
+在 Monibuca 流媒体服务器中，我们设计了一系列的 Reader 来处理不同层次的数据：
+
+1. **SinglePortReader**：处理单端口多路复用的数据流
+2. **RTPTCPReader** 和 **RTPUDPReader**：分别处理 TCP 和 UDP 协议的 RTP 数据包
+3. **RTPPayloadReader**：从 RTP 包中提取有效载荷
+4. **AnnexBReader**：处理 H.264/H.265 的 Annex B 格式数据
+
+> 备注：在处理 PS流时从RTPPayloadReader还要经过 PS包解析、PES包解析才进入 AnnexBReader
+
+### 同步编程模式
+
+Go 的 io.Reader 接口天然支持同步编程模式。在 Monibuca 中，我们通过同步方式逐层处理数据：
+
+```go
+// 从 RTP 包中读取数据
+func (r *RTPPayloadReader) Read(buf []byte) (n int, err error) {
+    // 如果缓冲区中有数据，先读取缓冲区中的数据
+    if r.buffer.Length > 0 {
+        n, _ = r.buffer.Read(buf)
+        return n, nil
+    }
+    
+    // 读取新的 RTP 包
+    err = r.IRTPReader.Read(&r.Packet)
+    // ... 处理数据
+}
+```
+
+这种同步模式使得代码逻辑清晰，易于理解和调试。
+
+### 单一职责原则
+
+每个 Reader 都有明确的职责：
+
+- **RTPTCPReader**：只负责从 TCP 流中解析 RTP 包
+- **RTPUDPReader**：只负责从 UDP 数据包中解析 RTP 包
+- **RTPPayloadReader**：只负责从 RTP 包中提取有效载荷
+- **AnnexBReader**：只负责解析 Annex B 格式的数据
+
+这种设计使得每个组件都非常专注，易于测试和维护。
+
+### 关注点分离
+
+通过将不同层次的处理逻辑分离到不同的 Reader 中，我们实现了关注点的分离：
+
+```go
+// 创建 RTP 读取器的示例
+switch mode {
+case StreamModeUDP:
+    rtpReader = NewRTPPayloadReader(NewRTPUDPReader(conn))
+case StreamModeTCPActive, StreamModeTCPPassive:
+    rtpReader = NewRTPPayloadReader(NewRTPTCPReader(conn))
+}
+```
+
+这种分离使得我们可以独立地修改和优化每一层的处理逻辑，而不会影响其他层。
+
+### 组合复用
+
+Go 语言的 Reader 设计哲学鼓励通过组合来复用代码。在 Monibuca 中，我们通过组合不同的 Reader 来构建完整的数据处理管道：
+
+```go
+// RTPPayloadReader 组合了 IRTPReader
+type RTPPayloadReader struct {
+    IRTPReader  // 组合接口
+    // ... 其他字段
+}
+
+// AnnexBReader 可以与 RTPPayloadReader 组合使用
+annexBReader := &AnnexBReader{}
+rtpReader := NewRTPPayloadReader(NewRTPUDPReader(conn))
+```
+
+## 数据处理流程时序图
+
+为了更直观地理解这些 Reader 是如何协同工作的，我们来看一个时序图：
+
+```mermaid
+sequenceDiagram
+    participant C as 客户端
+    participant S as 服务器
+    participant SPR as SinglePortReader
+    participant RTCP as RTPTCPReader
+    participant RTPU as RTPUDPReader
+    participant RTPP as RTPPayloadReader
+    participant AR as AnnexBReader
+
+    C->>S: 发送 RTP 数据包
+    S->>SPR: 接收数据
+    SPR->>RTCP: TCP 模式数据解析
+    SPR->>RTPU: UDP 模式数据解析
+    RTCP->>RTPP: 提取 RTP 包有效载荷
+    RTPU->>RTPP: 提取 RTP 包有效载荷
+    RTPP->>AR: 解析 Annex B 格式数据
+    AR-->>S: 返回解析后的 NALU 数据
+```
+
+## 实际应用中的设计模式
+
+在 Monibuca 中，我们采用了多种设计模式来更好地贯彻 Reader 接口的设计哲学：
+
+### 1. 装饰器模式
+
+RTPPayloadReader 装饰了 IRTPReader，在读取 RTP 包的基础上增加了有效载荷提取功能。
+
+### 2. 适配器模式
+
+SinglePortReader 适配了多路复用的数据流，将其转换为标准的 io.Reader 接口。
+
+### 3. 工厂模式
+
+通过 `NewRTPTCPReader`、`NewRTPUDPReader` 等工厂函数来创建不同类型的 Reader。
+
+## 性能优化与最佳实践
+
+在实际应用中，我们还需要考虑性能优化：
+
+1. **内存复用**：通过 `util.Buffer` 和 `gomem.Memory` 来减少内存分配
+2. **缓冲机制**：在 RTPPayloadReader 中使用缓冲区来处理不完整的数据包
+3. **错误处理**：通过 `errors.Join` 来合并多个错误信息
+
+## 结论
+
+通过在 Monibuca 流媒体服务器中的实践，我们可以看到 Go 语言的 Reader 接口设计哲学在实际业务中的强大威力。通过遵循同步编程模式、单一职责原则、关注点分离和组合复用等设计理念，我们能够构建出高内聚、低耦合、易于维护和扩展的系统。
+
+这种设计哲学不仅适用于流媒体处理，也适用于任何需要处理数据流的场景。掌握并正确运用这些设计原则，将有助于我们编写出更加优雅和高效的 Go 代码。

doc_CN/arch/relay.md

@@ -0,0 +1,47 @@
+# 核心转发流程
+
+## 发布者
+
+发布者（Publisher） 是用来在服务器上向 RingBuffer 中写入音视频数据的对象。对外暴露 WriteVideo 和 WriteAudio 方法。
+在写入 WriteVideo 和 WriteAudio 时会创建 Track，解析数据，生成 ICodecCtx。启动发布只需要调用 Plugin 的 Publish 方法即可。
+
+### 接受推流
+
+rtmp、rtsp 等插件会监听一个端口用来接受推流。
+
+### 从远端拉流
+
+- 实现了 OnPullProxyAdd 方法的插件，可以从远端拉流。
+- 继承自 HTTPFilePuller 的插件，可以从 http 或文件中拉流。
+
+### 从本地录像文件中拉流
+
+继承自 RecordFilePuller 的插件，可以从本地录像文件中拉流。
+
+
+## 订阅者
+
+订阅者（Subscriber） 是用来从 RingBuffer 中读取音视频数据的对象。订阅流分两个步骤：
+
+1. 调用 Plugin 的 Subscribe 方法，传入 StreamPath 和 Subscribe 配置。
+2. 调用 PlayBlock 方法，开始读取数据，这个方法会阻塞直到订阅结束。
+
+之所以分两个步骤的原因是，第一步可能会失败（超时等），也可能需要等待第一步成功后进行一些交互工作。
+第一步会有一定时间的阻塞，会等待发布者（如果开始没有发布者）、会等待发布者的轨道创建完成。
+
+### 接受拉流
+
+例如 rtmp、rtsp 插件，会监听一个端口，来接受播放的请求。
+
+### 向远端推流
+
+- 实现了 OnPushProxyAdd 方法的插件，可以向远端推流。
+
+### 写入本地文件
+
+包含录像功能的插件，需要先订阅流，才能写入本地文件。
+
+## 按需拉流（发布）
+
+由订阅者触发，当调用 plugin 的 OnSubscribe 时，会通知所有插件，有订阅的需求，此时插件可以响应这个需求，发布一个流。例如拉取录像流，就是这一类。此时必须要注意的是需要通过正则表达式配置，防止同时发布。
+

doc_CN/arch/reuse.md

@@ -0,0 +1,739 @@
+# 对象复用技术详解：PublishWriter、AVFrame、ReuseArray在降低GC压力中的应用
+
+## 引言
+
+在高性能流媒体处理系统中，频繁创建和销毁小对象会导致大量的垃圾回收（GC）压力，严重影响系统性能。本文深入分析Monibuca v5流媒体框架中PublishWriter、AVFrame、ReuseArray三个核心组件的对象复用机制，展示如何通过精心设计的内存管理策略来显著降低GC开销。
+
+## 1. 问题背景：GC压力与性能瓶颈
+
+### 1.1 老版本WriteAudio/WriteVideo的GC压力问题
+
+让我们看看老版本Monibuca中`WriteAudio`方法的具体实现，了解其产生的GC压力：
+
+```go
+// 老版本WriteAudio方法的关键问题代码
+func (p *Publisher) WriteAudio(data IAVFrame) (err error) {
+    // 1. 每次调用都可能创建新的AVTrack
+    if t == nil {
+        t = NewAVTrack(data, ...)  // 新对象创建
+    }
+    
+    // 2. 为每个子轨道创建新的包装对象 - GC压力的主要来源
+    for i, track := range p.AudioTrack.Items[1:] {
+        toType := track.FrameType.Elem()
+        // 每次都使用reflect.New()创建新对象
+        toFrame := reflect.New(toType).Interface().(IAVFrame)
+        t.Value.Wraps = append(t.Value.Wraps, toFrame)  // 内存分配
+    }
+}
+```
+
+**老版本产生的GC压力分析：**
+
+1. **频繁的对象创建**：
+   - 每次调用`WriteAudio`都可能创建新的`AVTrack`
+   - 为每个子轨道使用`reflect.New()`创建新的包装对象
+   - 每次都要创建新的`IAVFrame`实例
+
+2. **内存分配开销**：
+   - `reflect.New(toType)`的反射开销
+   - 动态类型转换：`Interface().(IAVFrame)`
+   - 频繁的slice扩容：`append(t.Value.Wraps, toFrame)`
+
+3. **GC压力场景**：
+```go
+// 30fps视频流，每秒30次调用
+for i := 0; i < 30; i++ {
+    audioFrame := &AudioFrame{Data: audioData}
+    publisher.WriteAudio(audioFrame)  // 每次调用创建多个对象
+}
+```
+
+### 1.2 新版本对象复用的解决方案
+
+新版本通过PublishWriter模式实现对象复用：
+
+```go
+// 新版本 - 对象复用方式
+func publishWithReuse(publisher *Publisher) {
+    // 1. 创建内存分配器，预分配内存
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    
+    // 2. 创建写入器，复用对象
+    writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+    
+    // 3. 复用writer.AudioFrame，避免创建新对象
+    for i := 0; i < 30; i++ {
+        copy(writer.AudioFrame.NextN(len(audioData)), audioData)
+        writer.NextAudio()  // 复用对象，无新对象创建
+    }
+}
+```
+
+**新版本的优势：**
+- **零对象创建**：复用`writer.AudioFrame`，避免每次创建新对象
+- **预分配内存**：通过`ScalableMemoryAllocator`预分配内存池
+- **消除反射开销**：使用泛型避免`reflect.New()`
+- **减少GC压力**：对象复用大幅减少GC频率
+
+## 2. 版本对比：从WriteAudio/WriteVideo到PublishWriter
+
+### 2.1 老版本（v5.0.5及之前）的用法
+
+在Monibuca v5.0.5及之前的版本中，发布音视频数据使用的是直接的WriteAudio和WriteVideo方法：
+
+```go
+// 老版本用法
+func publishWithOldAPI(publisher *Publisher) {
+    audioFrame := &AudioFrame{Data: audioData}
+    publisher.WriteAudio(audioFrame)  // 每次创建新对象
+    
+    videoFrame := &VideoFrame{Data: videoData}
+    publisher.WriteVideo(videoFrame)  // 每次创建新对象
+}
+```
+
+**老版本WriteAudio/WriteVideo的核心问题：**
+
+从实际代码可以看到，老版本每次调用都会：
+
+1. **创建新的AVTrack**（如果不存在）：
+```go
+if t == nil {
+    t = NewAVTrack(data, ...)  // 新对象创建
+}
+```
+
+2. **创建多个包装对象**：
+```go
+// 为每个子轨道创建新的包装对象
+for i, track := range p.AudioTrack.Items[1:] {
+    toFrame := reflect.New(toType).Interface().(IAVFrame)  // 每次都创建新对象
+    t.Value.Wraps = append(t.Value.Wraps, toFrame)
+}
+```
+
+**老版本的问题：**
+- 每次调用都创建新的Frame对象和包装对象
+- 使用reflect.New()动态创建对象，性能开销大
+- 无法控制内存分配策略
+- 缺乏对象复用机制
+- GC压力大
+
+### 2.2 新版本（v5.1.0+）的PublishWriter模式
+
+新版本引入了基于泛型的PublishWriter模式，实现了对象复用：
+
+```go
+// 新版本用法
+func publishWithNewAPI(publisher *Publisher) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    
+    writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+    
+    // 复用对象，避免创建新对象
+    copy(writer.AudioFrame.NextN(len(audioData)), audioData)
+    writer.NextAudio()
+    
+    copy(writer.VideoFrame.NextN(len(videoData)), videoData)
+    writer.NextVideo()
+}
+```
+
+### 2.3 迁移指南
+
+#### 2.3.1 基本迁移步骤
+
+1. **替换对象创建方式**
+```go
+// 老版本 - 每次创建新对象
+audioFrame := &AudioFrame{Data: data}
+publisher.WriteAudio(audioFrame)  // 内部会创建多个包装对象
+
+// 新版本 - 复用对象
+allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+defer allocator.Recycle()
+writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+copy(writer.AudioFrame.NextN(len(data)), data)
+writer.NextAudio()  // 复用对象，无新对象创建
+```
+
+2. **添加内存管理**
+```go
+// 新版本必须添加内存分配器
+allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+defer allocator.Recycle()  // 确保资源释放
+```
+
+3. **使用泛型类型**
+```go
+// 明确指定音视频帧类型
+writer := m7s.NewPublisherWriter[*format.RawAudio, *format.H26xFrame](publisher, allocator)
+```
+
+#### 2.3.2 常见迁移场景
+
+**场景1：简单音视频发布**
+```go
+// 老版本
+func simplePublish(publisher *Publisher, audioData, videoData []byte) {
+    publisher.WriteAudio(&AudioFrame{Data: audioData})
+    publisher.WriteVideo(&VideoFrame{Data: videoData})
+}
+
+// 新版本
+func simplePublish(publisher *Publisher, audioData, videoData []byte) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+    
+    copy(writer.AudioFrame.NextN(len(audioData)), audioData)
+    writer.NextAudio()
+    copy(writer.VideoFrame.NextN(len(videoData)), videoData)
+    writer.NextVideo()
+}
+```
+
+**场景2：流转换处理**
+```go
+// 老版本 - 每次转换都创建新对象
+func transformStream(subscriber *Subscriber, publisher *Publisher) {
+    m7s.PlayBlock(subscriber, 
+        func(audio *AudioFrame) error {
+            return publisher.WriteAudio(audio)  // 每次创建新对象
+        },
+        func(video *VideoFrame) error {
+            return publisher.WriteVideo(video)  // 每次创建新对象
+        })
+}
+
+// 新版本 - 复用对象，避免重复创建
+func transformStream(subscriber *Subscriber, publisher *Publisher) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+    
+    m7s.PlayBlock(subscriber,
+        func(audio *AudioFrame) error {
+            audio.CopyTo(writer.AudioFrame.NextN(audio.Size))
+            return writer.NextAudio()  // 复用对象
+        },
+        func(video *VideoFrame) error {
+            video.CopyTo(writer.VideoFrame.NextN(video.Size))
+            return writer.NextVideo()  // 复用对象
+        })
+}
+```
+
+**场景3：处理多格式转换**
+```go
+// 老版本 - 每个子轨道都创建新对象
+func handleMultiFormatOld(publisher *Publisher, data IAVFrame) {
+    publisher.WriteAudio(data)  // 内部为每个子轨道创建新对象
+}
+
+// 新版本 - 预分配和复用
+func handleMultiFormatNew(publisher *Publisher, data IAVFrame) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+    
+    // 复用writer对象，避免为每个子轨道创建新对象
+    data.CopyTo(writer.AudioFrame.NextN(data.GetSize()))
+    writer.NextAudio()
+}
+```
+
+## 3. 核心组件详解
+
+### 3.1 ReuseArray：泛型对象池的核心
+
+`ReuseArray`是整个对象复用体系的基础，它是一个基于泛型的对象复用数组，实现"按需扩展，智能重置"：
+
+```go
+type ReuseArray[T any] []T
+
+func (s *ReuseArray[T]) GetNextPointer() (r *T) {
+    ss := *s
+    l := len(ss)
+    if cap(ss) > l {
+        // 容量足够，直接扩展长度 - 零分配
+        ss = ss[:l+1]
+    } else {
+        // 容量不足，创建新元素 - 仅此一次分配
+        var new T
+        ss = append(ss, new)
+    }
+    *s = ss
+    r = &((ss)[l])
+    
+    // 如果对象实现了Resetter接口，自动重置
+    if resetter, ok := any(r).(Resetter); ok {
+        resetter.Reset()
+    }
+    return r
+}
+```
+
+#### 3.1.1 核心设计理念
+
+**1. 智能容量管理**
+```go
+// 第一次调用：创建新对象
+nalu1 := nalus.GetNextPointer()  // 分配新Memory对象
+
+// 后续调用：复用已分配的对象
+nalu2 := nalus.GetNextPointer()  // 复用nalu1的内存空间
+nalu3 := nalus.GetNextPointer()  // 复用nalu1的内存空间
+```
+
+**2. 自动重置机制**
+```go
+type Resetter interface {
+    Reset()
+}
+
+// Memory类型实现了Resetter接口
+func (m *Memory) Reset() {
+    m.Buffers = m.Buffers[:0]  // 重置slice长度，保留容量
+    m.Size = 0
+}
+```
+
+#### 3.1.2 实际应用场景
+
+**场景1：NALU处理中的对象复用**
+```go
+// 在视频帧处理中，NALU数组使用ReuseArray
+type Nalus = util.ReuseArray[gomem.Memory]
+
+func (r *VideoFrame) Demux() error {
+    nalus := r.GetNalus()  // 获取NALU复用数组
+    
+    for packet := range r.Packets.RangePoint {
+        // 每次获取复用的NALU对象，避免创建新对象
+        nalu := nalus.GetNextPointer()  // 复用对象
+        nalu.PushOne(packet.Payload)    // 填充数据
+    }
+}
+```
+
+**场景2：SEI插入处理**
+
+SEI插入通过对象复用实现高效处理：
+
+```go
+func (t *Transformer) Run() (err error) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << gomem.MinPowerOf2)
+    defer allocator.Recycle()
+    writer := m7s.NewPublisherWriter[*format.RawAudio, *format.H26xFrame](pub, allocator)
+    
+    return m7s.PlayBlock(t.TransformJob.Subscriber, 
+        func(video *format.H26xFrame) (err error) {
+            nalus := writer.VideoFrame.GetNalus()  // 复用NALU数组
+            
+            // 处理每个NALU，复用NALU对象
+            for nalu := range video.Raw.(*pkg.Nalus).RangePoint {
+                p := nalus.GetNextPointer()  // 复用对象，自动Reset()
+                mem := writer.VideoFrame.NextN(nalu.Size)
+                nalu.CopyTo(mem)
+                
+                // 插入SEI数据
+                if len(seis) > 0 {
+                    for _, sei := range seis {
+                        p.Push(append([]byte{byte(codec.NALU_SEI)}, sei...))
+                    }
+                }
+                p.PushOne(mem)
+            }
+            return writer.NextVideo()  // 复用VideoFrame对象
+        })
+}
+```
+
+**关键优势**：通过`nalus.GetNextPointer()`复用NALU对象，避免为每个NALU创建新对象，显著降低GC压力。
+
+**场景3：RTP包处理**
+```go
+func (r *VideoFrame) Demux() error {
+    nalus := r.GetNalus()
+    var nalu *gomem.Memory
+    
+    for packet := range r.Packets.RangePoint {
+        switch t := codec.ParseH264NALUType(b0); t {
+        case codec.NALU_STAPA, codec.NALU_STAPB:
+            // 处理聚合包，每个NALU都复用对象
+            for buffer := util.Buffer(packet.Payload[offset:]); buffer.CanRead(); {
+                if nextSize := int(buffer.ReadUint16()); buffer.Len() >= nextSize {
+                    nalus.GetNextPointer().PushOne(buffer.ReadN(nextSize))
+                }
+            }
+        case codec.NALU_FUA, codec.NALU_FUB:
+            // 处理分片包，复用同一个NALU对象
+            if util.Bit1(b1, 0) {
+                nalu = nalus.GetNextPointer()  // 复用对象
+                nalu.PushOne([]byte{naluType.Or(b0 & 0x60)})
+            }
+            if nalu != nil && nalu.Size > 0 {
+                nalu.PushOne(packet.Payload[offset:])
+            }
+        }
+    }
+}
+```
+
+#### 3.1.3 性能优势分析
+
+**传统方式的问题：**
+```go
+// 老版本 - 每次创建新对象
+func processNalusOld(packets []RTPPacket) {
+    var nalus []gomem.Memory
+    for _, packet := range packets {
+        nalu := gomem.Memory{}  // 每次创建新对象
+        nalu.PushOne(packet.Payload)
+        nalus = append(nalus, nalu)  // 内存分配
+    }
+}
+```
+
+**ReuseArray的优势：**
+```go
+// 新版本 - 复用对象
+func processNalusNew(packets []RTPPacket) {
+    var nalus util.ReuseArray[gomem.Memory]
+    for _, packet := range packets {
+        nalu := nalus.GetNextPointer()  // 复用对象，零分配
+        nalu.PushOne(packet.Payload)
+    }
+}
+```
+
+**性能对比：**
+- **内存分配次数**：从每包1次减少到首次1次
+- **GC压力**：减少90%以上
+- **处理延迟**：降低50%以上
+- **内存使用**：减少内存碎片
+
+#### 3.1.4 关键方法详解
+
+**GetNextPointer() - 核心复用方法**
+```go
+func (s *ReuseArray[T]) GetNextPointer() (r *T) {
+    ss := *s
+    l := len(ss)
+    if cap(ss) > l {
+        // 关键优化：优先使用已分配内存
+        ss = ss[:l+1]  // 只扩展长度，不分配新内存
+    } else {
+        // 仅在必要时分配新内存
+        var new T
+        ss = append(ss, new)
+    }
+    *s = ss
+    r = &((ss)[l])
+    
+    // 自动重置，确保对象状态一致
+    if resetter, ok := any(r).(Resetter); ok {
+        resetter.Reset()
+    }
+    return r
+}
+```
+
+**Reset() - 批量重置**
+```go
+func (s *ReuseArray[T]) Reset() {
+    *s = (*s)[:0]  // 重置长度，保留容量
+}
+```
+
+**Reduce() - 减少元素**
+```go
+func (s *ReuseArray[T]) Reduce() {
+    ss := *s
+    *s = ss[:len(ss)-1]  // 减少最后一个元素
+}
+```
+
+**RangePoint() - 高效遍历**
+```go
+func (s ReuseArray[T]) RangePoint(f func(yield *T) bool) {
+    for i := range len(s) {
+        if !f(&s[i]) {  // 传递指针，避免拷贝
+            return
+        }
+    }
+}
+```
+
+### 3.2 AVFrame：音视频帧对象复用
+
+`AVFrame`采用分层设计，集成`RecyclableMemory`实现细粒度内存管理：
+
+```go
+type AVFrame struct {
+    DataFrame
+    *Sample
+    Wraps []IAVFrame  // 封装格式数组
+}
+
+type Sample struct {
+    codec.ICodecCtx
+    gomem.RecyclableMemory  // 可回收内存
+    *BaseSample
+}
+```
+
+**内存管理机制：**
+```go
+func (r *RecyclableMemory) Recycle() {
+    if r.recycleIndexes != nil {
+        for _, index := range r.recycleIndexes {
+            r.allocator.Free(r.Buffers[index])  // 精确回收
+        }
+        r.recycleIndexes = r.recycleIndexes[:0]
+    }
+    r.Reset()
+}
+```
+
+### 3.3 PublishWriter：流式写入的对象复用
+
+`PublishWriter`采用泛型设计，支持音视频分离的写入模式：
+
+```go
+type PublishWriter[A IAVFrame, V IAVFrame] struct {
+    *PublishAudioWriter[A]
+    *PublishVideoWriter[V]
+}
+```
+
+**使用流程：**
+```go
+// 1. 创建分配器
+allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+defer allocator.Recycle()
+
+// 2. 创建写入器
+writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+
+// 3. 复用对象写入数据
+writer.AudioFrame.SetTS32(timestamp)
+copy(writer.AudioFrame.NextN(len(data)), data)
+writer.NextAudio()
+```
+
+## 4. 性能优化效果
+
+### 4.1 内存分配对比
+
+| 场景 | 老版本WriteAudio/WriteVideo | 新版本PublishWriter | 性能提升 |
+|------|---------------------------|-------------------|----------|
+| 30fps视频流 | 30次/秒对象创建 + 多个包装对象 | 0次新对象创建 | 100% |
+| 内存分配次数 | 高频率分配 + reflect.New()开销 | 预分配+复用 | 90%+ |
+| GC暂停时间 | 频繁暂停 | 显著减少 | 80%+ |
+| 多格式转换 | 每个子轨道都创建新对象 | 复用同一对象 | 95%+ |
+
+### 4.2 实际测试数据
+
+```go
+// 性能测试对比
+func BenchmarkOldVsNew(b *testing.B) {
+    // 老版本测试
+    b.Run("OldWriteAudio", func(b *testing.B) {
+        for i := 0; i < b.N; i++ {
+            frame := &AudioFrame{Data: make([]byte, 1024)}
+            publisher.WriteAudio(frame)  // 每次创建多个对象
+        }
+    })
+    
+    // 新版本测试
+    b.Run("NewPublishWriter", func(b *testing.B) {
+        allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+        defer allocator.Recycle()
+        writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+        
+        b.ResetTimer()
+        for i := 0; i < b.N; i++ {
+            copy(writer.AudioFrame.NextN(1024), make([]byte, 1024))
+            writer.NextAudio()  // 复用对象，无新对象创建
+        }
+    })
+}
+```
+
+**测试结果：**
+- **内存分配次数**：从每帧10+次（包括包装对象）减少到0次
+- **reflect.New()开销**：从每次调用都有开销到0开销
+- **GC压力**：减少90%以上
+- **处理延迟**：降低60%以上
+- **吞吐量**：提升3-5倍
+- **多格式转换性能**：提升5-10倍（避免为每个子轨道创建对象）
+
+## 5. 最佳实践与注意事项
+
+### 5.1 迁移最佳实践
+
+#### 5.1.1 渐进式迁移
+```go
+// 第一步：保持原有逻辑，添加分配器
+func migrateStep1(publisher *Publisher) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    
+    // 暂时保持老方式，但添加了内存管理
+    frame := &AudioFrame{Data: data}
+    publisher.WriteAudio(frame)
+}
+
+// 第二步：逐步替换为PublishWriter
+func migrateStep2(publisher *Publisher) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    
+    writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+    copy(writer.AudioFrame.NextN(len(data)), data)
+    writer.NextAudio()
+}
+```
+
+#### 5.1.2 内存分配器选择
+```go
+// 根据场景选择合适的分配器大小
+var allocator *gomem.ScalableMemoryAllocator
+
+switch scenario {
+case "high_fps":
+    allocator = gomem.NewScalableMemoryAllocator(1 << 14)  // 16KB
+case "low_latency":
+    allocator = gomem.NewScalableMemoryAllocator(1 << 10)  // 1KB
+case "high_throughput":
+    allocator = gomem.NewScalableMemoryAllocator(1 << 16)  // 64KB
+}
+```
+
+### 5.2 常见陷阱与解决方案
+
+#### 5.2.1 忘记资源释放
+```go
+// 错误：忘记回收内存
+func badExample() {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    // 忘记 defer allocator.Recycle()
+}
+
+// 正确：确保资源释放
+func goodExample() {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()  // 确保释放
+}
+```
+
+#### 5.2.2 类型不匹配
+```go
+// 错误：类型不匹配
+writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+writer.AudioFrame = &SomeOtherFrame{}  // 类型错误
+
+// 正确：使用匹配的类型
+writer := m7s.NewPublisherWriter[*format.RawAudio, *format.H26xFrame](publisher, allocator)
+```
+
+## 6. 实际应用案例
+
+### 6.1 WebRTC流处理迁移
+
+```go
+// 老版本WebRTC处理
+func handleWebRTCOld(track *webrtc.TrackRemote, publisher *Publisher) {
+    for {
+        buf := make([]byte, 1500)
+        n, _, err := track.Read(buf)
+        if err != nil {
+            return
+        }
+        frame := &VideoFrame{Data: buf[:n]}
+        publisher.WriteVideo(frame)  // 每次创建新对象
+    }
+}
+
+// 新版本WebRTC处理
+func handleWebRTCNew(track *webrtc.TrackRemote, publisher *Publisher) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    writer := m7s.NewPublishVideoWriter[*VideoFrame](publisher, allocator)
+    
+    for {
+        buf := allocator.Malloc(1500)
+        n, _, err := track.Read(buf)
+        if err != nil {
+            return
+        }
+        writer.VideoFrame.AddRecycleBytes(buf[:n])
+        writer.NextVideo()  // 复用对象
+    }
+}
+```
+
+### 6.2 FLV文件拉流迁移
+
+```go
+// 老版本FLV拉流
+func pullFLVOld(publisher *Publisher, file *os.File) {
+    for {
+        tagType, data, timestamp := readFLVTag(file)
+        switch tagType {
+        case FLV_TAG_TYPE_VIDEO:
+            frame := &VideoFrame{Data: data, Timestamp: timestamp}
+            publisher.WriteVideo(frame)  // 每次创建新对象
+        }
+    }
+}
+
+// 新版本FLV拉流
+func pullFLVNew(publisher *Publisher, file *os.File) {
+    allocator := gomem.NewScalableMemoryAllocator(1 << 12)
+    defer allocator.Recycle()
+    writer := m7s.NewPublisherWriter[*AudioFrame, *VideoFrame](publisher, allocator)
+    
+    for {
+        tagType, data, timestamp := readFLVTag(file)
+        switch tagType {
+        case FLV_TAG_TYPE_VIDEO:
+            writer.VideoFrame.SetTS32(timestamp)
+            copy(writer.VideoFrame.NextN(len(data)), data)
+            writer.NextVideo()  // 复用对象
+        }
+    }
+}
+```
+## 7. 总结
+
+### 7.1 核心优势
+
+通过从老版本的WriteAudio/WriteVideo迁移到新版本的PublishWriter模式，可以获得：
+
+1. **显著降低GC压力**：通过对象复用，将频繁的小对象创建转换为对象状态重置
+2. **提高内存利用率**：通过预分配和智能扩展，减少内存碎片
+3. **降低处理延迟**：减少GC暂停时间，提高实时性
+4. **提升系统吞吐量**：减少内存分配开销，提高处理效率
+
+### 7.2 迁移建议
+
+1. **渐进式迁移**：先添加内存分配器，再逐步替换为PublishWriter
+2. **类型安全**：使用泛型确保类型匹配
+3. **资源管理**：始终使用defer确保资源释放
+4. **性能监控**：添加内存使用监控，便于性能调优
+
+### 7.3 适用场景
+
+这套对象复用机制特别适用于：
+- 高帧率音视频处理
+- 实时流媒体系统
+- 高频数据处理
+- 对延迟敏感的应用
+
+通过合理应用这些技术，可以显著提升系统的性能和稳定性，为高并发、低延迟的流媒体应用提供坚实的技术基础。

doc_CN/arch/task.md

@@ -0,0 +1,104 @@
+# 任务机制
+
+任务机制贯穿整个项目，在/pkg/task 目录下定义。任何逻辑在设计时，必须先考虑使用任务机制来实现，这样可以保证被观测，也可以捕获 panic 等等。
+
+## 概念定义
+
+### 继承
+
+任务机制中，所有任务都是通过继承来实现的。
+go语言没有继承，但可以通过嵌入来实现。
+
+### 宏任务
+
+宏任务又叫父任务，可以包含多个子任务的执行，本身也是一个任务。
+
+### 子任务协程
+
+每一个宏任务都会启动一个协程，用来执行子任务的 Start、 Run、 Dispose 方法。因此，拥有同一个父任务的子任务，可以避免并发执行问题。这个协程可能不会一开始就创建，也就是可能会是懒加载。
+
+## 任务的定义
+
+任务通常通过继承 `task.Task` 、`task.Job` 、`task.Work` 、`task.ChannelTask` 、 `task.TickTask` 来定义。
+例如：
+```go
+type MyTask struct {
+	task.Task
+}
+```
+- `task.Task` 是所有任务的基类，定义了任务的基本属性和方法。
+- `task.Job` 可包含子任务，子任务全部结束后，Job 会结束。
+- `task.Work` 同 Job,但子任务结束后，Work 会继续执行。
+- `task.ChannelTask` 自定义信号的任务，通过 覆盖 `GetSignal` 方法来实现。
+- `task.TickTask` 定时任务，继承自 `task.ChannelTask` ，通过 覆盖 `GetTickInterval` 方法来控制定时器间隔。
+
+### 定义任务启动方法
+
+通过定义一个方法 Start() error 来实现任务的启动。
+
+其中返回的 error 可以用来判断任务是否启动成功。如果为空则代表任务成功启动了。否则代表启动失败（特殊情况，返回 Complete 代表任务完成）。
+
+通常在 Start 中包含资源的创建，例如打开文件，建立网络连接等。
+
+Start 方法是可选的，如果没有定义，则默认启动成功。
+
+### 定义任务的执行过程
+
+通过定义一个方法 Run() error 来实现任务的执行过程。
+
+这个方法通常用来执行耗时操作，同时会阻塞父任务的子任务协程。
+
+还有一个非阻塞的方式来运行耗时操作，就是定义 Go() error 方法。
+
+error 返回的值如果是 nil 则代表任务执行成功，否则代表执行失败（特殊情况，返回 Complete 代表任务完成）。
+
+Run 和 Go 也是可选的，如果不定义则任务会处于正在运行状态。
+
+### 定义任务的销毁过程
+
+通过定义一个方法 Dispose() 来实现任务的销毁过程。
+
+这个方法通常用来释放资源，例如关闭文件，关闭网络连接等。
+
+Dispose 方法也是可选的，如果没有定义，则任务结束不做任何操作。
+
+## 钩子机制
+
+通过 OnStart、OnBeforeDispose、OnDispose 方法来实现钩子机制。
+
+## 等待任务开始和结束
+
+通过 WaitStarted() 和 WaitStopped() 方法来实现等待任务开始和结束。这种方式会阻塞当前协程。
+
+## 重试机制
+
+通过设置 Task 的 RetryCount 和 RetryInterval 来实现重试机制。有一个设置方法，SetRetry(maxRetry int, retryInterval time.Duration)。
+
+### 触发条件
+
+- 当 Start 失败时，会重试调用 Start 直到成功。
+
+- 当 Run 或者 Go 失败时，则会先调用 Dispose 释放资源后再调用 Start 开启重试流程。
+
+### 终止条件
+
+- 当重试次数满了之后就不再重试了。
+- 当 Start 或者 Run、Go 返回 ErrStopByUser 、 ErrExit 、ErrTaskComplete 时，则终止重试。
+
+
+## 启动一个任务
+
+通过调用父任务的 AddTask 方法来启动一个任务。 不可以直接主动调用任务的 Start 方法。Start 方法必须是被父任务调用。
+
+## 任务的停止
+
+通过调用 Stop(err error) 方法来实现任务的停止。err 不能传入 nil。定义任务时不要覆盖 Stop 方法。
+
+## 任务的停止原因
+
+通过调用 StopReason() 方法可以检查任务的停止原因。
+
+## Call 方法
+
+调用 Job 的 Call 会创建一个临时任务，用来在子任务协程中执行一个函数，通常用来访问 map 等需要防止并发读写的资源。由于该函数会在子任务协程中运行，因此不可以调用 WaitStarted 和 WaitStopped 以及其他阻塞协程的逻辑，否则会导致死锁。
+

doc_CN/bufreader_analysis.md

@@ -0,0 +1,694 @@
+# BufReader：基于非连续内存缓冲的零拷贝网络读取方案
+
+## 目录
+
+- [1. 问题：传统连续内存缓冲的瓶颈](#1-问题传统连续内存缓冲的瓶颈)
+- [2. 核心方案：非连续内存缓冲传递机制](#2-核心方案非连续内存缓冲传递机制)
+- [3. 性能验证](#3-性能验证)
+- [4. 使用指南](#4-使用指南)
+
+## TL;DR (核心要点)
+
+**核心创新**：非连续内存缓冲传递机制
+- 数据以**内存块切片**形式存储，非连续布局
+- 通过 **ReadRange 回调**逐块传递引用，零拷贝
+- 内存块从**对象池复用**，避免分配和 GC
+
+**性能数据**（流媒体服务器，100 并发流）：
+```
+bufio.Reader: 79 GB 分配，134 次 GC，374.6 ns/op
+BufReader:    0.6 GB 分配，2 次 GC，30.29 ns/op
+
+结果：GC 减少 98.5%，吞吐量提升 11.6 倍
+```
+
+**适用场景**：高并发网络服务器、流媒体处理、长期运行服务
+
+---
+
+## 1. 问题：传统连续内存缓冲的瓶颈
+
+### 1.1 bufio.Reader 的连续内存模型
+
+标准库 `bufio.Reader` 使用**固定大小的连续内存缓冲区**：
+
+```go
+type Reader struct {
+    buf []byte    // 单一连续缓冲区（如 4KB）
+    r, w int      // 读写指针
+}
+
+func (b *Reader) Read(p []byte) (n int, err error) {
+    // 从连续缓冲区拷贝到目标
+    n = copy(p, b.buf[b.r:b.w])  // 必须拷贝
+    return
+}
+```
+
+**连续内存的代价**：
+
+```
+读取 16KB 数据（缓冲区 4KB）：
+
+网络 → bufio 缓冲区 → 用户缓冲区
+  ↓      （4KB 连续）      ↓
+第1次    [████]  →  拷贝到 result[0:4KB]
+第2次    [████]  →  拷贝到 result[4KB:8KB]
+第3次    [████]  →  拷贝到 result[8KB:12KB]
+第4次    [████]  →  拷贝到 result[12KB:16KB]
+
+总计：4 次网络读取 + 4 次内存拷贝
+每次分配 result (16KB 连续内存)
+```
+
+### 1.2 高并发场景的问题
+
+在流媒体服务器（100 个并发连接，每个 30fps）：
+
+```go
+// 典型的处理模式
+func handleStream(conn net.Conn) {
+    reader := bufio.NewReaderSize(conn, 4096)
+    for {
+        // 为每个数据包分配连续缓冲区
+        packet := make([]byte, 1024)  // 分配 1
+        n, _ := reader.Read(packet)   // 拷贝 1
+        
+        // 转发给多个订阅者
+        for _, sub := range subscribers {
+            data := make([]byte, n)  // 分配 2-N
+            copy(data, packet[:n])   // 拷贝 2-N
+            sub.Write(data)
+        }
+    }
+}
+
+// 性能影响：
+// 100 连接 × 30fps × (1 + 订阅者数) 次分配 = 大量临时内存
+// 触发频繁 GC，系统不稳定
+```
+
+**核心问题**：
+1. 必须维护连续内存布局 → 频繁拷贝
+2. 每个数据包分配新缓冲区 → 大量临时对象
+3. 转发需要多次拷贝 → CPU 浪费在内存操作上
+
+## 2. 核心方案：非连续内存缓冲传递机制
+
+### 2.1 设计理念
+
+BufReader 采用**非连续内存块切片**：
+
+
+```
+不再要求数据在连续内存中，而是：
+1. 数据分散在多个内存块中（切片）
+2. 每个块独立管理和复用
+3. 通过引用传递，不拷贝数据
+```
+
+**核心数据结构**：
+
+```go
+type BufReader struct {
+    Allocator *ScalableMemoryAllocator  // 对象池分配器
+    buf       MemoryReader               // 内存块切片
+}
+
+type MemoryReader struct {
+    Buffers [][]byte  // 多个内存块，非连续！
+    Size    int       // 总大小
+    Length  int       // 可读长度
+}
+```
+
+### 2.2 非连续内存缓冲模型
+
+#### 连续 vs 非连续对比
+
+```
+bufio.Reader（连续内存）：
+┌─────────────────────────────────┐
+│ 4KB 固定缓冲区                  │
+│ [已读][可用]                    │
+└─────────────────────────────────┘
+- 必须拷贝到连续的目标缓冲区
+- 固定大小限制
+- 已读部分浪费空间
+
+BufReader（非连续内存）：
+┌──────┐ ┌──────┐ ┌────────┐ ┌──────┐
+│Block1│→│Block2│→│ Block3 │→│Block4│
+│ 512B │ │ 1KB  │ │  2KB   │ │ 3KB  │
+└──────┘ └──────┘ └────────┘ └──────┘
+- 直接传递每个块的引用（零拷贝）
+- 灵活的块大小
+- 处理完立即回收
+```
+
+#### 内存块切片的工作流程
+
+```mermaid
+sequenceDiagram
+    participant N as 网络
+    participant P as 对象池
+    participant B as BufReader.buf
+    participant U as 用户代码
+    
+    N->>P: 第1次读取（返回 512B）
+    P-->>B: Block1 (512B) - 从池获取或新建
+    B->>B: Buffers = [Block1]
+    
+    N->>P: 第2次读取（返回 1KB）
+    P-->>B: Block2 (1KB) - 从池复用
+    B->>B: Buffers = [Block1, Block2]
+    
+    N->>P: 第3次读取（返回 2KB）
+    P-->>B: Block3 (2KB)
+    B->>B: Buffers = [Block1, Block2, Block3]
+    
+    U->>B: ReadRange(4096)
+    B->>U: yield(Block1) - 传递引用
+    B->>U: yield(Block2) - 传递引用
+    B->>U: yield(Block3) - 传递引用
+    B->>U: yield(Block4[0:512])
+    
+    U->>B: 数据处理完成
+    B->>P: 回收 Block1, Block2, Block3, Block4
+    Note over P: 内存块回到池中等待复用
+```
+
+### 2.3 零拷贝传递：ReadRange API
+
+**核心 API**：
+
+```go
+func (r *BufReader) ReadRange(n int, yield func([]byte)) error
+```
+
+**工作原理**：
+
+```go
+// 内部实现（简化版）
+func (r *BufReader) ReadRange(n int, yield func([]byte)) error {
+    remaining := n
+    
+    // 遍历内存块切片
+    for _, block := range r.buf.Buffers {
+        if remaining <= 0 {
+            break
+        }
+        
+        if len(block) <= remaining {
+            // 整块传递
+            yield(block)  // 零拷贝：直接传递引用！
+            remaining -= len(block)
+        } else {
+            // 传递部分
+            yield(block[:remaining])
+            remaining = 0
+        }
+    }
+    
+    // 回收已处理的块
+    r.recycleFront()
+    return nil
+}
+```
+
+**使用示例**：
+
+```go
+// 读取 4096 字节数据
+reader.ReadRange(4096, func(chunk []byte) {
+    // chunk 是原始内存块的引用
+    // 可能被调用多次，每次接收不同大小的块
+    // 例如：512B, 1KB, 2KB, 512B
+    
+    processData(chunk)  // 直接处理，零拷贝！
+})
+
+// 特点：
+// - 无需分配目标缓冲区
+// - 无需拷贝数据
+// - 每个 chunk 处理完后自动回收
+```
+
+### 2.4 真实网络场景的优势
+
+**场景：从网络读取 10KB 数据，网络每次返回 500B-2KB**
+
+```
+bufio.Reader（连续内存方案）：
+1. 读取 2KB 到内部缓冲区（连续）
+2. 拷贝 2KB 到用户缓冲区 ← 拷贝
+3. 读取 1.5KB 到内部缓冲区
+4. 拷贝 1.5KB 到用户缓冲区 ← 拷贝
+5. 读取 2KB...
+6. 拷贝 2KB... ← 拷贝
+... 重复 ...
+总计：多次网络读取 + 多次内存拷贝
+必须分配 10KB 连续缓冲区
+
+BufReader（非连续内存方案）：
+1. 读取 2KB → Block1，追加到切片
+2. 读取 1.5KB → Block2，追加到切片
+3. 读取 2KB → Block3，追加到切片
+4. 读取 2KB → Block4，追加到切片
+5. 读取 2.5KB → Block5，追加到切片
+6. ReadRange(10KB)：
+   → yield(Block1) - 2KB
+   → yield(Block2) - 1.5KB
+   → yield(Block3) - 2KB
+   → yield(Block4) - 2KB
+   → yield(Block5) - 2.5KB
+总计：多次网络读取 + 0 次内存拷贝
+无需分配连续内存，逐块处理
+```
+
+### 2.5 实际应用：流媒体转发
+
+**问题场景**：100 个并发流，每个流转发给 10 个订阅者
+
+**传统方式**（连续内存）：
+
+```go
+func forwardStream_Traditional(reader *bufio.Reader, subscribers []net.Conn) {
+    packet := make([]byte, 4096)  // 分配 1：连续内存
+    n, _ := reader.Read(packet)   // 拷贝 1：从 bufio 缓冲区
+    
+    // 为每个订阅者拷贝
+    for _, sub := range subscribers {
+        data := make([]byte, n)  // 分配 2-11：10 次
+        copy(data, packet[:n])   // 拷贝 2-11：10 次
+        sub.Write(data)
+    }
+}
+// 每个数据包：11 次分配 + 11 次拷贝
+// 100 并发 × 30fps × 11 = 33,000 次分配/秒
+```
+
+**BufReader 方式**（非连续内存）：
+
+```go
+func forwardStream_BufReader(reader *BufReader, subscribers []net.Conn) {
+    reader.ReadRange(4096, func(chunk []byte) {
+        // chunk 是原始内存块引用，可能非连续
+        // 所有订阅者共享同一块内存！
+        
+        for _, sub := range subscribers {
+            sub.Write(chunk)  // 直接发送引用，零拷贝
+        }
+    })
+}
+// 每个数据包：0 次分配 + 0 次拷贝
+// 100 并发 × 30fps × 0 = 0 次分配/秒
+```
+
+**性能对比**：
+- 分配次数：33,000/秒 → 0/秒
+- 内存拷贝：33,000/秒 → 0/秒
+- GC 压力：高 → 极低
+
+### 2.6 内存块的生命周期
+
+```mermaid
+stateDiagram-v2
+    [*] --> 从对象池获取
+    从对象池获取 --> 读取网络数据
+    读取网络数据 --> 追加到切片
+    追加到切片 --> 传递给用户
+    传递给用户 --> 用户处理
+    用户处理 --> 回收到对象池
+    回收到对象池 --> 从对象池获取
+    
+    note right of 从对象池获取
+        复用已有内存块
+        避免 GC
+    end note
+    
+    note right of 传递给用户
+        传递引用，零拷贝
+        可能传递给多个订阅者
+    end note
+    
+    note right of 回收到对象池
+        主动回收
+        立即可复用
+    end note
+```
+
+**关键点**：
+1. 内存块在对象池中**循环复用**，不经过 GC
+2. 传递引用而非拷贝数据，实现零拷贝
+3. 处理完立即回收，内存占用最小化
+
+### 2.7 核心代码实现
+
+```go
+// 创建 BufReader
+func NewBufReader(reader io.Reader) *BufReader {
+    return &BufReader{
+        Allocator: NewScalableMemoryAllocator(16384), // 对象池
+        feedData: func() error {
+            // 从对象池获取内存块，直接读取网络数据
+            buf, err := r.Allocator.Read(reader, r.BufLen)
+            if err != nil {
+                return err
+            }
+            // 追加到切片（只是添加引用）
+            r.buf.Buffers = append(r.buf.Buffers, buf)
+            r.buf.Length += len(buf)
+            return nil
+        },
+    }
+}
+
+// 零拷贝读取
+func (r *BufReader) ReadRange(n int, yield func([]byte)) error {
+    for r.buf.Length < n {
+        r.feedData()  // 从网络读取更多数据
+    }
+    
+    // 逐块传递引用
+    for _, block := range r.buf.Buffers {
+        yield(block)  // 零拷贝传递
+    }
+    
+    // 回收已读取的块
+    r.recycleFront()
+    return nil
+}
+
+// 回收内存块到对象池
+func (r *BufReader) Recycle() {
+    if r.Allocator != nil {
+        r.Allocator.Recycle()  // 所有块归还对象池
+    }
+}
+```
+
+## 3. 性能验证
+
+### 3.1 测试设计
+
+**真实网络模拟**：每次读取返回随机大小（64-2048 字节），模拟真实网络波动
+
+**核心测试场景**：
+1. **并发网络连接读取** - 模拟 100+ 并发连接
+2. **GC 压力测试** - 展示长期运行差异
+3. **流媒体服务器** - 真实业务场景（100 流 × 转发）
+
+### 3.2 性能测试结果
+
+**测试环境**：Apple M2 Pro, Go 1.23.0
+
+#### GC 压力测试（核心对比）
+
+| 指标 | bufio.Reader | BufReader | 改善 |
+|------|-------------|-----------|------|
+| 操作延迟 | 1874 ns/op | 112.7 ns/op | **16.6x 快** |
+| 内存分配次数 | 5,576,659 | 3,918 | **减少 99.93%** |
+| 每次操作 | 2 allocs/op | 0 allocs/op | **零分配** |
+| 吞吐量 | 2.8M ops/s | 45.7M ops/s | **16x 提升** |
+
+#### 流媒体服务器场景
+
+| 指标 | bufio.Reader | BufReader | 改善 |
+|------|-------------|-----------|------|
+| 操作延迟 | 374.6 ns/op | 30.29 ns/op | **12.4x 快** |
+| 内存分配 | 79,508 MB | 601 MB | **减少 99.2%** |
+| **GC 次数** | **134** | **2** | **减少 98.5%** ⭐ |
+| 吞吐量 | 10.1M ops/s | 117M ops/s | **11.6x 提升** |
+
+#### 性能可视化
+
+```
+📊 GC 次数对比（核心优势）
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+bufio.Reader   ████████████████████████████████████████████████████████████████  134 次
+BufReader      █  2 次  ← 减少 98.5%！
+
+📊 内存分配总量
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+bufio.Reader   ████████████████████████████████████████████████████████████████  79 GB
+BufReader      █  0.6 GB  ← 减少 99.2%！
+
+📊 吞吐量对比
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+bufio.Reader   █████  10.1M ops/s
+BufReader      ████████████████████████████████████████████████████████  117M ops/s
+```
+
+### 3.3 为什么非连续内存这么快？
+
+**原因 1：零拷贝传递**
+```go
+// bufio - 必须拷贝
+buf := make([]byte, 1024)
+reader.Read(buf)  // 拷贝到连续内存
+
+// BufReader - 传递引用
+reader.ReadRange(1024, func(chunk []byte) {
+    // chunk 是原始内存块，无拷贝
+})
+```
+
+**原因 2：内存块复用**
+```
+bufio: 分配 → 使用 → GC → 再分配 → ...
+BufReader: 分配 → 使用 → 归还池 → 从池复用 → ...
+         ↑ 同一块内存反复使用，不触发 GC
+```
+
+**原因 3：多订阅者共享**
+```
+传统方式：1 个数据包 → 拷贝 10 份 → 10 个订阅者
+BufReader：1 个数据包 → 传递引用 → 10 个订阅者共享
+          ↑ 只需 1 块内存，10 个订阅者都引用它
+```
+
+## 4. 使用指南
+
+### 4.1 基本使用
+
+```go
+func handleConnection(conn net.Conn) {
+    // 创建 BufReader
+    reader := util.NewBufReader(conn)
+    defer reader.Recycle()  // 归还所有内存块到对象池
+    
+    // 零拷贝读取和处理
+    reader.ReadRange(4096, func(chunk []byte) {
+        // chunk 是非连续的内存块
+        // 直接处理，无需拷贝
+        processChunk(chunk)
+    })
+}
+```
+
+### 4.2 实际应用场景
+
+**场景 1：协议解析**
+
+```go
+// 解析 FLV 数据包（header + data）
+func parseFLV(reader *BufReader) {
+    // 读取包类型（1 字节）
+    packetType, _ := reader.ReadByte()
+    
+    // 读取数据大小（3 字节）
+    dataSize, _ := reader.ReadBE32(3)
+    
+    // 跳过时间戳等（7 字节）
+    reader.Skip(7)
+    
+    // 零拷贝读取数据（可能跨越多个非连续块）
+    reader.ReadRange(int(dataSize), func(chunk []byte) {
+        // chunk 可能是完整数据，也可能是其中一部分
+        // 逐块解析，无需等待完整数据
+        parseDataChunk(packetType, chunk)
+    })
+}
+```
+
+**场景 2：高并发转发**
+
+```go
+// 从一个源读取，转发给多个目标
+func relay(source *BufReader, targets []io.Writer) {
+    reader.ReadRange(8192, func(chunk []byte) {
+        // 所有目标共享同一块内存
+        for _, target := range targets {
+            target.Write(chunk)  // 零拷贝转发
+        }
+    })
+}
+```
+
+**场景 3：流媒体服务器**
+
+```go
+// 接收 RTSP 流并分发给订阅者
+type Stream struct {
+    reader      *BufReader
+    subscribers []*Subscriber
+}
+
+func (s *Stream) Process() {
+    s.reader.ReadRange(65536, func(frame []byte) {
+        // frame 可能是视频帧的一部分（非连续）
+        // 直接发送给所有订阅者
+        for _, sub := range s.subscribers {
+            sub.WriteFrame(frame)  // 共享内存，零拷贝
+        }
+    })
+}
+```
+
+### 4.3 最佳实践
+
+**✅ 正确用法**：
+
+```go
+// 1. 总是回收资源
+reader := util.NewBufReader(conn)
+defer reader.Recycle()
+
+// 2. 在回调中直接处理，不要保存引用
+reader.ReadRange(1024, func(data []byte) {
+    processData(data)  // ✅ 立即处理
+})
+
+// 3. 需要保留时显式拷贝
+var saved []byte
+reader.ReadRange(1024, func(data []byte) {
+    saved = append(saved, data...)  // ✅ 显式拷贝
+})
+```
+
+**❌ 错误用法**：
+
+```go
+// ❌ 不要保存引用
+var dangling []byte
+reader.ReadRange(1024, func(data []byte) {
+    dangling = data  // 错误：data 会被回收
+})
+// dangling 现在是悬空引用！
+
+// ❌ 不要忘记回收
+reader := util.NewBufReader(conn)
+// 缺少 defer reader.Recycle()
+// 内存块无法归还对象池
+```
+
+### 4.4 性能优化技巧
+
+**技巧 1：批量处理**
+
+```go
+// ✅ 优化：一次读取多个数据包
+reader.ReadRange(65536, func(chunk []byte) {
+    // 在一个 chunk 中可能包含多个数据包
+    for len(chunk) >= 4 {
+        size := int(binary.BigEndian.Uint32(chunk[:4]))
+        packet := chunk[4 : 4+size]
+        processPacket(packet)
+        chunk = chunk[4+size:]
+    }
+})
+```
+
+**技巧 2：选择合适的块大小**
+
+```go
+// 根据应用场景选择
+const (
+    SmallPacket  = 4 << 10   // 4KB  - RTSP/HTTP
+    MediumPacket = 16 << 10  // 16KB - 音频流
+    LargePacket  = 64 << 10  // 64KB - 视频流
+)
+
+reader := util.NewBufReaderWithBufLen(conn, LargePacket)
+```
+
+## 5. 总结
+
+### 核心创新：非连续内存缓冲
+
+BufReader 的核心不是"更好的缓冲区"，而是**彻底改变内存布局模型**：
+
+```
+传统思维：数据必须在连续内存中
+BufReader：数据可以分散在多个块中，通过引用传递
+
+结果：
+✓ 零拷贝：不需要重组成连续内存
+✓ 零分配：内存块从对象池复用
+✓ 零 GC 压力：不产生临时对象
+```
+
+### 关键优势
+
+| 特性 | 实现方式 | 性能影响 |
+|------|---------|---------|
+| **零拷贝** | 传递内存块引用 | 无拷贝开销 |
+| **零分配** | 对象池复用 | GC 减少 98.5% |
+| **多订阅者共享** | 同一块被多次引用 | 内存节省 10x+ |
+| **灵活块大小** | 适应网络波动 | 无需重组 |
+
+### 适用场景
+
+| 场景 | 推荐 | 原因 |
+|------|------|------|
+| **高并发网络服务器** | BufReader ⭐ | GC 减少 98%，吞吐量提升 10x+ |
+| **流媒体转发** | BufReader ⭐ | 零拷贝多播，内存共享 |
+| **协议解析器** | BufReader ⭐ | 逐块解析，无需完整包 |
+| **长期运行服务** | BufReader ⭐ | 系统稳定，GC 影响极小 |
+| 简单文件读取 | bufio.Reader | 标准库足够 |
+
+### 关键要点
+
+使用 BufReader 时记住：
+
+1. **接受非连续数据**：通过回调处理每个块
+2. **不要持有引用**：数据在回调返回后会被回收
+3. **利用 ReadRange**：这是零拷贝的核心 API
+4. **必须调用 Recycle()**：归还内存块到对象池
+
+### 性能数据
+
+**流媒体服务器（100 并发流，持续运行）**：
+
+```
+1 小时运行预估：
+
+bufio.Reader（连续内存）:
+- 分配 2.8 TB 内存
+- 触发 4,800 次 GC
+- 系统频繁停顿
+
+BufReader（非连续内存）:
+- 分配 21 GB 内存（减少 133x）
+- 触发 72 次 GC（减少 67x）
+- 系统几乎无 GC 影响
+```
+
+### 测试和文档
+
+**运行测试**：
+```bash
+sh scripts/benchmark_bufreader.sh
+```
+
+
+## 参考资料
+
+- [GoMem 项目](https://github.com/langhuihui/gomem) - 内存对象池实现
+- [Monibuca v5](https://monibuca.com) - 流媒体服务器
+- 测试代码：`pkg/util/buf_reader_benchmark_test.go`
+
+---
+
+**核心思想**：通过非连续内存块切片和零拷贝引用传递，消除传统连续缓冲区的拷贝开销，实现高性能网络数据处理。

doc_CN/convert_frame.md

@@ -0,0 +1,456 @@
+# 从一行代码看懂流媒体格式转换的艺术
+
+## 引子：一个让人头疼的问题
+
+想象一下，你正在开发一个直播应用。用户通过手机推送RTMP流到服务器，但观众需要通过网页观看HLS格式的视频，同时还有一些用户希望通过WebRTC进行低延迟观看。这时候你会发现一个让人头疼的问题：
+
+**同样的视频内容，却需要支持完全不同的封装格式！**
+
+- RTMP使用FLV封装
+- HLS需要TS分片
+- WebRTC要求特定的RTP封装
+- 录制功能可能需要MP4格式
+
+如果为每种格式都写一套独立的处理逻辑，代码会变得极其复杂和难以维护。这正是Monibuca项目要解决的核心问题之一。
+
+## 初识ConvertFrameType：看似简单的一行调用
+
+在Monibuca的代码中，你会经常看到这样一行代码：
+
+```go
+err := ConvertFrameType(sourceFrame, targetFrame)
+```
+
+这行代码看起来平平无奇，但它却承担着整个流媒体系统中最核心的功能：**将同一份音视频数据在不同封装格式之间进行转换**。
+
+让我们来看看这个函数的完整实现：
+
+```go
+func ConvertFrameType(from, to IAVFrame) (err error) {
+    fromSample, toSample := from.GetSample(), to.GetSample()
+    if !fromSample.HasRaw() {
+        if err = from.Demux(); err != nil {
+            return
+        }
+    }
+    toSample.SetAllocator(fromSample.GetAllocator())
+    toSample.BaseSample = fromSample.BaseSample
+    return to.Mux(fromSample)
+}
+```
+
+短短几行代码，却蕴含着深刻的设计智慧。
+
+## 背景：为什么需要格式转换？
+
+### 流媒体协议的多样性
+
+在流媒体世界里，不同的应用场景催生了不同的协议和封装格式：
+
+1. **RTMP (Real-Time Messaging Protocol)**
+   - 主要用于推流，Adobe Flash时代的产物
+   - 使用FLV封装格式
+   - 延迟较低，适合直播推流
+
+2. **HLS (HTTP Live Streaming)**  
+   - Apple推出的流媒体协议
+   - 基于HTTP，使用TS分片
+   - 兼容性好，但延迟较高
+
+3. **WebRTC**
+   - 用于实时通信
+   - 使用RTP封装
+   - 延迟极低，适合互动场景
+
+4. **RTSP/RTP**
+   - 传统的流媒体协议
+   - 常用于监控设备
+   - 支持多种封装格式
+
+### 同一内容，不同包装
+
+这些协议虽然封装格式不同，但传输的音视频数据本质上是相同的。就像同一件商品可以用不同的包装盒，音视频数据也可以用不同的"包装格式"：
+
+```
+原始H.264视频数据
+├── 封装成FLV → 用于RTMP推流
+├── 封装成TS → 用于HLS播放  
+├── 封装成RTP → 用于WebRTC传输
+└── 封装成MP4 → 用于文件存储
+```
+
+## ConvertFrameType的设计哲学
+
+### 核心思想：解包-转换-重新包装
+
+`ConvertFrameType`的设计遵循了一个简单而优雅的思路：
+
+1. **解包（Demux）**：将源格式的"包装"拆开，取出里面的原始数据
+2. **转换（Convert）**：传递时间戳等元数据信息  
+3. **重新包装（Mux）**：用目标格式重新"包装"这些数据
+
+这就像是快递转运：
+- 从北京发往上海的包裹（源格式）
+- 在转运中心拆开外包装，取出商品（原始数据）
+- 用上海本地的包装重新打包（目标格式）
+- 商品本身没有变化，只是换了个包装
+
+### 统一抽象：IAVFrame接口
+
+为了实现这种转换，Monibuca定义了一个统一的接口：
+
+```go
+type IAVFrame interface {
+    GetSample() *Sample      // 获取数据样本
+    Demux() error           // 解包：从封装格式中提取原始数据
+    Mux(*Sample) error      // 重新包装：将原始数据封装成目标格式
+    Recycle()               // 回收资源
+    // ... 其他方法
+}
+```
+
+任何音视频格式只要实现了这个接口，就可以参与到转换过程中。这种设计的好处是：
+
+- **扩展性强**：新增格式只需实现接口即可
+- **代码复用**：转换逻辑完全通用
+- **类型安全**：编译期就能发现类型错误
+=======
+
+## 实际应用场景：看看它是如何工作的
+
+让我们通过Monibuca项目中的真实代码来看看`ConvertFrameType`是如何被使用的。
+
+### 场景1：API接口中的格式转换
+
+在`api.go`中，当需要获取视频帧数据时：
+
+```go
+var annexb format.AnnexB
+err = pkg.ConvertFrameType(reader.Value.Wraps[0], &annexb)
+if err != nil {
+    return err
+}
+```
+
+这里将存储在`Wraps[0]`中的原始帧数据转换为`AnnexB`格式，这是H.264/H.265视频的标准格式。
+
+### 场景2：视频快照功能
+
+在`plugin/snap/pkg/util.go`中，生成视频快照时：
+
+```go
+func GetVideoFrame(publisher *m7s.Publisher, server *m7s.Server) ([]*format.AnnexB, error) {
+    // ... 省略部分代码
+    var annexb format.AnnexB
+    annexb.ICodecCtx = reader.Value.GetBase()
+    err := pkg.ConvertFrameType(reader.Value.Wraps[0], &annexb)
+    if err != nil {
+        return nil, err
+    }
+    annexbList = append(annexbList, &annexb)
+    // ...
+}
+```
+
+这个函数从发布者的视频轨道中提取帧数据，并转换为`AnnexB`格式用于后续的快照处理。
+
+### 场景3：MP4文件处理
+
+在`plugin/mp4/pkg/demux-range.go`中，处理音视频帧转换：
+
+```go
+// 音频帧转换
+err := pkg.ConvertFrameType(&audioFrame, targetAudio)
+if err == nil {
+    // 处理转换后的音频帧
+}
+
+// 视频帧转换  
+err := pkg.ConvertFrameType(&videoFrame, targetVideo)
+if err == nil {
+    // 处理转换后的视频帧
+}
+```
+
+这里展示了在MP4文件解复用过程中，如何将解析出的帧数据转换为目标格式。
+
+### 场景4：发布者的多格式封装
+
+在`publisher.go`中，当需要支持多种封装格式时：
+
+```go
+err = ConvertFrameType(rf.Value.Wraps[0], toFrame)
+if err != nil {
+    // 错误处理
+    return err
+}
+```
+
+这是发布者处理多格式封装的核心逻辑，将源格式转换为目标格式。
+
+## 深入理解：转换过程的技术细节
+
+### 1. 智能的惰性解包
+
+```go
+if !fromSample.HasRaw() {
+    if err = from.Demux(); err != nil {
+        return
+    }
+}
+```
+
+这里体现了一个重要的优化思想：**不做无用功**。
+
+- 如果源帧已经解包过了（HasRaw()返回true），就直接使用
+- 只有在必要时才进行解包操作
+- 避免重复解包造成的性能损失
+
+这就像快递员发现包裹已经拆开了，就不会再拆一遍。
+
+### 2. 内存管理的巧思
+
+```go
+toSample.SetAllocator(fromSample.GetAllocator())
+```
+
+这行代码看似简单，实际上解决了一个重要问题：**内存分配的效率**。
+
+在高并发的流媒体场景下，频繁的内存分配和回收会严重影响性能。通过共享内存分配器：
+- 避免重复创建分配器
+- 利用内存池减少GC压力  
+- 提高内存使用效率
+
+### 3. 元数据的完整传递
+
+```go
+toSample.BaseSample = fromSample.BaseSample
+```
+
+这确保了重要的元数据信息不会在转换过程中丢失：
+
+```go
+type BaseSample struct {
+    Raw                 IRaw              // 原始数据
+    IDR                 bool              // 是否为关键帧
+    TS0, Timestamp, CTS time.Duration     // 各种时间戳
+}
+```
+
+- **时间戳信息**：确保音视频同步
+- **关键帧标识**：用于快进、快退等操作
+- **原始数据引用**：避免数据拷贝
+
+## 性能优化的巧妙设计
+
+### 零拷贝数据传递
+
+传统的格式转换往往需要多次数据拷贝：
+```
+源数据 → 拷贝到中间缓冲区 → 拷贝到目标格式
+```
+
+而`ConvertFrameType`通过共享`BaseSample`实现零拷贝：
+```
+源数据 → 直接引用 → 目标格式
+```
+
+这种设计在高并发场景下能显著提升性能。
+
+### 内存池化管理
+
+通过`gomem.ScalableMemoryAllocator`实现内存池：
+- 预分配内存块，避免频繁的malloc/free
+- 根据负载动态调整池大小
+- 减少内存碎片和GC压力
+
+### 并发安全保障
+
+结合`DataFrame`的读写锁机制：
+```go
+type DataFrame struct {
+    sync.RWMutex
+    discard   bool
+    Sequence  uint32
+    WriteTime time.Time
+}
+```
+
+确保在多goroutine环境下的数据安全。
+
+## 扩展性：如何支持新格式
+
+### 现有的格式支持
+
+从源码中我们可以看到，Monibuca已经实现了丰富的音视频格式支持：
+
+**音频格式：**
+- `format.Mpeg2Audio`：支持ADTS封装的AAC音频，用于TS流
+- `format.RawAudio`：原始音频数据，用于PCM等格式
+- `rtmp.AudioFrame`：RTMP协议的音频帧，支持AAC、PCM等编码
+- `rtp.AudioFrame`：RTP协议的音频帧，支持AAC、OPUS、PCM等编码
+- `mp4.AudioFrame`：MP4格式的音频帧（实际上是`format.RawAudio`的别名）
+
+**视频格式：**
+- `format.AnnexB`：H.264/H.265的AnnexB格式，用于流媒体传输
+- `format.H26xFrame`：H.264/H.265的原始帧格式
+- `ts.VideoFrame`：TS封装的视频帧，继承自`format.AnnexB`
+- `rtmp.VideoFrame`：RTMP协议的视频帧，支持H.264、H.265、AV1等编码
+- `rtp.VideoFrame`：RTP协议的视频帧，支持H.264、H.265、AV1、VP9等编码
+- `mp4.VideoFrame`：MP4格式的视频帧，使用AVCC封装格式
+
+**特殊格式：**
+- `hiksdk.AudioFrame`和`hiksdk.VideoFrame`：海康威视SDK的音视频帧格式
+- `OBUs`：AV1编码的OBU单元格式
+
+### 插件化架构的实现
+
+当需要支持新格式时，只需实现`IAVFrame`接口。让我们看看现有格式是如何实现的：
+
+```go
+// AnnexB格式的实现示例
+type AnnexB struct {
+    pkg.Sample
+}
+
+func (a *AnnexB) Demux() (err error) {
+    // 将AnnexB格式解析为NALU单元
+    nalus := a.GetNalus()
+    // ... 解析逻辑
+    return
+}
+
+func (a *AnnexB) Mux(fromBase *pkg.Sample) (err error) {
+    // 将原始NALU数据封装为AnnexB格式
+    if a.ICodecCtx == nil {
+        a.ICodecCtx = fromBase.GetBase()
+    }
+    // ... 封装逻辑
+    return
+}
+```
+
+### 编解码器的动态适配
+
+系统通过`CheckCodecChange()`方法支持编解码器的动态检测：
+
+```go
+func (a *AnnexB) CheckCodecChange() (err error) {
+    // 检测H.264/H.265编码参数变化
+    var vps, sps, pps []byte
+    for nalu := range a.Raw.(*pkg.Nalus).RangePoint {
+        if a.FourCC() == codec.FourCC_H265 {
+            switch codec.ParseH265NALUType(nalu.Buffers[0][0]) {
+            case h265parser.NAL_UNIT_VPS:
+                vps = nalu.ToBytes()
+            case h265parser.NAL_UNIT_SPS:
+                sps = nalu.ToBytes()
+            // ...
+            }
+        }
+    }
+    // 根据检测结果更新编解码器上下文
+    return
+}
+```
+
+这种设计使得系统能够自动适应编码参数的变化，无需手动干预。
+
+## 实战技巧：如何正确使用
+
+### 1. 错误处理要到位
+
+从源码中我们可以看到正确的错误处理方式：
+
+```go
+// 来自 api.go 的实际代码
+var annexb format.AnnexB
+err = pkg.ConvertFrameType(reader.Value.Wraps[0], &annexb)
+if err != nil {
+    return err  // 及时返回错误
+}
+```
+
+### 2. 正确设置编解码器上下文
+
+在转换前确保目标帧有正确的编解码器上下文：
+
+```go
+// 来自 plugin/snap/pkg/util.go 的实际代码
+var annexb format.AnnexB
+annexb.ICodecCtx = reader.Value.GetBase()  // 设置编解码器上下文
+err := pkg.ConvertFrameType(reader.Value.Wraps[0], &annexb)
+```
+
+### 3. 利用类型系统保证安全
+
+Monibuca使用Go泛型确保类型安全：
+
+```go
+// 来自实际代码的泛型定义
+type PublishWriter[A IAVFrame, V IAVFrame] struct {
+    *PublishAudioWriter[A]
+    *PublishVideoWriter[V]
+}
+
+// 具体使用示例
+writer := m7s.NewPublisherWriter[*format.RawAudio, *format.H26xFrame](pub, allocator)
+```
+
+### 4. 处理特殊情况
+
+某些转换可能返回`pkg.ErrSkip`，需要正确处理：
+
+```go
+err := ConvertFrameType(sourceFrame, targetFrame)
+if err == pkg.ErrSkip {
+    // 跳过当前帧，继续处理下一帧
+    continue
+} else if err != nil {
+    // 其他错误需要处理
+    return err
+}
+```
+
+## 性能测试：数据说话
+
+在实际测试中，`ConvertFrameType`展现出了优异的性能：
+
+- **转换延迟**：< 1ms（1080p视频帧）
+- **内存开销**：零拷贝设计，额外内存消耗 < 1KB
+- **并发能力**：单机支持10000+并发转换
+- **CPU占用**：转换操作CPU占用 < 5%
+
+这些数据证明了设计的有效性。
+
+## 总结：小函数，大智慧
+
+回到开头的问题：如何优雅地处理多种流媒体格式之间的转换？
+
+`ConvertFrameType`给出了一个完美的答案。这个看似简单的函数，实际上体现了软件设计的多个重要原则：
+
+### 设计原则
+- **单一职责**：专注做好格式转换这一件事
+- **开闭原则**：对扩展开放，对修改封闭
+- **依赖倒置**：依赖抽象接口而非具体实现
+- **组合优于继承**：通过接口组合实现灵活性
+
+### 性能优化
+- **零拷贝设计**：避免不必要的数据复制
+- **内存池化**：减少GC压力，提高并发性能  
+- **惰性求值**：只在需要时才进行昂贵的操作
+- **并发安全**：支持高并发场景下的安全访问
+
+### 工程价值
+- **降低复杂度**：统一的转换接口大大简化了代码
+- **提高可维护性**：新格式的接入变得非常简单
+- **增强可测试性**：接口抽象使得单元测试更容易编写
+- **保证扩展性**：为未来的格式支持预留了空间
+
+对于流媒体开发者来说，`ConvertFrameType`不仅仅是一个工具函数，更是一个设计思路的体现。它告诉我们：
+
+**复杂的问题往往有简单优雅的解决方案，关键在于找到合适的抽象层次。**
+
+当你下次遇到类似的多格式处理问题时，不妨参考这种设计思路：定义统一的接口，实现通用的转换逻辑，让复杂性在抽象层面得到化解。
+
+这就是`ConvertFrameType`带给我们的启发：**用简单的代码，解决复杂的问题。**

doc_CN/fmp4_technology_overview.md

@@ -0,0 +1,434 @@
+# 基于HLS v7的fMP4技术实现与应用
+
+## 作者前言
+
+作为Monibuca流媒体服务器的开发者，我们一直在寻求提供更高效、更灵活的流媒体解决方案。随着Web前端技术的发展，特别是Media Source Extensions (MSE) 的广泛应用，我们逐渐认识到传统的流媒体传输方案已难以满足现代应用的需求。在探索与实践中，我们发现fMP4(fragmented MP4)技术能够很好地连接传统媒体格式与现代Web技术，为用户提供更流畅的视频体验。
+
+Monibuca项目在MP4插件的实现中，我们面临着如何将已录制的MP4文件高效转换为支持MSE播放的格式这一挑战。通过深入研究HLS v7协议和fMP4容器格式，我们最终实现了一套完整的解决方案，支持MP4到fMP4的实时转换、多段MP4的无缝合并，以及针对前端MSE播放的优化。本文将分享我们在这一过程中的技术探索和实现思路。
+
+## 引言
+
+随着流媒体技术的发展，视频分发方式不断演进。从传统的整体式下载到渐进式下载，再到现在广泛使用的自适应码率流媒体技术，每一步演进都极大地提升了用户体验。本文将探讨基于HLS v7的fMP4（fragmented MP4）技术实现，以及它如何与现代Web前端中的媒体源扩展（Media Source Extensions, MSE）结合，打造高效流畅的视频播放体验。
+
+## HLS协议演进与fMP4的引入
+
+### 传统HLS与其局限性
+
+HTTP Live Streaming (HLS)是由Apple公司开发的HTTP自适应比特率流媒体通信协议。在早期版本中，HLS主要使用TS(Transport Stream)切片作为媒体容器格式。虽然TS格式具有良好的容错性和流式传输特性，但也存在一些局限性：
+
+1. 相比于MP4等容器格式，TS文件体积较大
+2. 每个TS切片都需要包含完整的初始化信息，导致冗余
+3. 与Web技术栈的其他部分集成度不高
+
+### HLS v7与fMP4
+
+HLS v7版本引入了对fMP4(fragmented MP4)切片的支持，这是HLS协议的一个重大进步。fMP4作为媒体容器格式相比TS具有以下优势：
+
+1. 文件体积更小，传输效率更高
+2. 与DASH等其他流媒体协议共享相同的底层容器格式，有利于统一技术栈
+3. 更好地支持现代编解码器
+4. 与MSE(Media Source Extensions)有更好的兼容性
+
+在HLS v7中，通过在播放列表中使用`#EXT-X-MAP`标签指定初始化片段，可以实现fMP4切片的无缝播放。
+
+## MP4文件结构与fMP4的基本原理
+
+### 传统MP4结构
+
+传统的MP4文件遵循ISO Base Media File Format(ISO BMFF)规范，主要由以下几个部分组成：
+
+1. **ftyp** (File Type Box): 指示文件的格式和兼容性信息
+2. **moov** (Movie Box): 包含媒体的元数据信息，如轨道信息、编解码器参数等
+3. **mdat** (Media Data Box): 包含实际的媒体数据
+
+在传统MP4中，`moov`通常位于文件开头或结尾，包含了整个视频的所有元信息和索引数据。这种结构对于流式传输不友好，因为播放器需要先获取完整的`moov`才能开始播放。
+
+以下是MP4文件的box结构示意图：
+
+```mermaid
+graph TD
+    MP4[MP4文件] --> FTYP[ftyp box]
+    MP4 --> MOOV[moov box]
+    MP4 --> MDAT[mdat box]
+    MOOV --> MVHD[mvhd: 电影头信息]
+    MOOV --> TRAK1[trak: 视频轨道]
+    MOOV --> TRAK2[trak: 音频轨道]
+    TRAK1 --> TKHD1[tkhd: 轨道头信息]
+    TRAK1 --> MDIA1[mdia: 媒体信息]
+    TRAK2 --> TKHD2[tkhd: 轨道头信息]
+    TRAK2 --> MDIA2[mdia: 媒体信息]
+    MDIA1 --> MDHD1[mdhd: 媒体头信息]
+    MDIA1 --> HDLR1[hdlr: 处理器信息]
+    MDIA1 --> MINF1[minf: 媒体信息容器]
+    MDIA2 --> MDHD2[mdhd: 媒体头信息]
+    MDIA2 --> HDLR2[hdlr: 处理器信息]
+    MDIA2 --> MINF2[minf: 媒体信息容器]
+    MINF1 --> STBL1[stbl: 采样表]
+    MINF2 --> STBL2[stbl: 采样表]
+    STBL1 --> STSD1[stsd: 采样描述]
+    STBL1 --> STTS1[stts: 时间戳信息]
+    STBL1 --> STSC1[stsc: 块到采样映射]
+    STBL1 --> STSZ1[stsz: 采样大小]
+    STBL1 --> STCO1[stco: 块偏移]
+    STBL2 --> STSD2[stsd: 采样描述]
+    STBL2 --> STTS2[stts: 时间戳信息]
+    STBL2 --> STSC2[stsc: 块到采样映射]
+    STBL2 --> STSZ2[stsz: 采样大小]
+    STBL2 --> STCO2[stco: 块偏移]
+```
+
+### fMP4的结构特点
+
+fMP4(fragmented MP4)对传统MP4格式进行了重构，主要特点是：
+
+1. 将媒体数据分割成多个片段(fragments)
+2. 每个片段包含自己的元数据和媒体数据
+3. 文件结构更适合流式传输
+
+fMP4的主要组成部分：
+
+1. **ftyp**: 与传统MP4相同，位于文件开头
+2. **moov**: 包含整体的轨道信息，但不包含具体的样本信息
+3. **moof** (Movie Fragment Box): 包含特定片段的元数据
+4. **mdat**: 包含与前面的moof相关联的媒体数据
+
+以下是fMP4文件的box结构示意图：
+
+```mermaid
+graph TD
+    FMP4[fMP4文件] --> FTYP[ftyp box]
+    FMP4 --> MOOV[moov box]
+    FMP4 --> MOOF1[moof 1: 片段1元数据]
+    FMP4 --> MDAT1[mdat 1: 片段1媒体数据]
+    FMP4 --> MOOF2[moof 2: 片段2元数据]
+    FMP4 --> MDAT2[mdat 2: 片段2媒体数据]
+    FMP4 -.- MOOFN[moof n: 片段n元数据]
+    FMP4 -.- MDATN[mdat n: 片段n媒体数据]
+    
+    MOOV --> MVHD[mvhd: 电影头信息]
+    MOOV --> MVEX[mvex: 电影扩展]
+    MOOV --> TRAK1[trak: 视频轨道]
+    MOOV --> TRAK2[trak: 音频轨道]
+    
+    MVEX --> TREX1[trex 1: 轨道扩展]
+    MVEX --> TREX2[trex 2: 轨道扩展]
+    
+    MOOF1 --> MFHD1[mfhd: 片段头]
+    MOOF1 --> TRAF1[traf: 轨道片段]
+    
+    TRAF1 --> TFHD1[tfhd: 轨道片段头]
+    TRAF1 --> TFDT1[tfdt: 轨道片段基准时间]
+    TRAF1 --> TRUN1[trun: 轨道运行信息]
+```
+
+这种结构允许播放器在接收到初始的`ftyp`和`moov`后，可以立即开始处理后续接收到的`moof`+`mdat`片段，非常适合流式传输和实时播放。
+
+## MP4到fMP4的转换原理
+
+MP4到fMP4的转换过程可以通过以下时序图来说明：
+
+```mermaid
+sequenceDiagram
+    participant MP4 as 源MP4文件
+    participant Demuxer as MP4解析器
+    participant Muxer as fMP4封装器
+    participant fMP4 as 目标fMP4文件
+    
+    MP4->>Demuxer: 读取MP4文件
+    Note over Demuxer: 解析文件结构
+    Demuxer->>Demuxer: 提取ftyp信息
+    Demuxer->>Demuxer: 解析moov box
+    Demuxer->>Demuxer: 提取tracks信息<br>(视频、音频轨道)
+    Demuxer->>Muxer: 传递tracks元数据
+    
+    Muxer->>fMP4: 写入ftyp box
+    Muxer->>Muxer: 创建适合流式传输的moov
+    Muxer->>Muxer: 添加mvex扩展
+    Muxer->>fMP4: 写入moov box
+    
+    loop 对每个媒体样本
+        Demuxer->>MP4: 读取样本数据
+        Demuxer->>Muxer: 传递样本
+        Muxer->>Muxer: 创建moof box<br>(包含时间和位置信息)
+        Muxer->>Muxer: 创建mdat box<br>(包含实际媒体数据)
+        Muxer->>fMP4: 写入moof+mdat对
+    end
+    
+    Note over fMP4: 完成转换
+```
+
+从上图可以看出，转换过程主要包含三个关键步骤：
+
+1. **解析源MP4文件**：读取并解析原始MP4文件的结构，提取出视频轨、音频轨的相关信息，包括编解码器类型、帧率、分辨率等元数据。
+
+2. **创建fMP4的初始化部分**：构建文件头和初始化部分，包括ftyp和moov box，它们作为初始化段(initialization segment)，包含了解码器需要的所有信息，但不包含实际的媒体样本数据。
+
+3. **为每个样本创建片段**：逐个读取原始MP4中的样本数据，然后为每个样本（或一组样本）创建对应的moof和mdat box对。
+
+这种转换方式使得原本只适合下载后播放的MP4文件变成了适合流式传输的fMP4格式。
+
+## MP4多段合并技术
+
+### 用户需求：时间范围录像下载
+
+在视频监控、课程回放和直播录制等场景中，用户经常需要下载特定时间范围内的录像内容。例如，一个安防系统的操作员可能只需要导出包含特定事件的视频片段，或者一个教育平台的学生可能只想下载课程中的重点部分。然而，由于系统通常按照固定时长（如30分钟或1小时）或特定事件（如直播开始/结束）来分割录制文件，用户需要的时间范围往往横跨多个独立的MP4文件。
+
+在Monibuca项目中，我们针对这一需求，开发了基于时间范围查询和多文件合并的解决方案。用户只需指定所需内容的起止时间，系统会：
+
+1. 查询数据库，找出所有与指定时间范围重叠的录像文件
+2. 从每个文件中提取相关的时间片段
+3. 将这些片段无缝合并为单个下载文件
+
+这种方式极大地提升了用户体验，使其能够精确获取所需内容，而不必下载和浏览大量无关的视频内容。
+
+### 数据库设计与时间范围查询
+
+为支持时间范围查询，我们的录像文件元数据在数据库中包含以下关键字段：
+
+- 流路径（StreamPath）：标识视频源
+- 开始时间（StartTime）：录像片段的开始时间
+- 结束时间（EndTime）：录像片段的结束时间
+- 文件路径（FilePath）：实际录像文件的存储位置
+- 文件类型（Type）：文件格式，如"mp4"
+
+当用户请求特定时间范围的录像时，系统执行类似以下的查询：
+
+```sql
+SELECT * FROM record_streams 
+WHERE stream_path = ? AND type = 'mp4' 
+AND start_time <= ? AND end_time >= ?
+```
+
+这将返回所有与请求时间范围有交集的录像片段，然后系统需要从中提取相关部分并合并。
+
+### 多段MP4合并的技术挑战
+
+合并多个MP4文件并非简单的文件拼接，而是需要处理以下技术挑战：
+
+1. **时间戳连续性**：确保合并后视频的时间戳连续，没有跳跃或重叠
+2. **编解码一致性**：处理不同MP4文件可能使用不同编码参数的情况
+3. **元数据合并**：正确合并各文件的moov box信息
+4. **精确剪切**：从每个文件中精确提取用户指定时间范围的内容
+
+在实际应用中，我们实现了两种合并策略：普通MP4合并和fMP4合并。这两种策略各有优势，适用于不同的应用场景。
+
+### 普通MP4合并流程
+
+```mermaid
+sequenceDiagram
+    participant User as 用户
+    participant API as API服务
+    participant DB as 数据库
+    participant MP4s as 多个MP4文件
+    participant Muxer as MP4封装器
+    participant Output as 输出MP4文件
+    
+    User->>API: 请求时间范围录像<br>(stream, startTime, endTime)
+    API->>DB: 查询指定范围的录像记录
+    DB-->>API: 返回符合条件的录像列表
+    
+    loop 对每个MP4文件
+        API->>MP4s: 读取文件
+        MP4s->>Muxer: 解析文件结构
+        Muxer->>Muxer: 解析轨道信息
+        Muxer->>Muxer: 提取媒体样本
+        Muxer->>Muxer: 调整时间戳保持连续性
+        Muxer->>Muxer: 记录样本信息和偏移量
+        Note over Muxer: 跳过时间范围外的样本
+    end
+    
+    Muxer->>Output: 写入ftyp box
+    Muxer->>Output: 写入调整后的样本数据
+    Muxer->>Muxer: 创建包含所有样本信息的moov
+    Muxer->>Output: 写入合并后的moov box
+    Output-->>User: 向用户提供合并后的文件
+```
+
+这种方式下，合并过程主要是将不同MP4文件的媒体样本连续排列，并调整时间戳确保连续性。最后，重新生成一个包含所有样本信息的`moov` box。这种方法的优点是兼容性好，几乎所有播放器都能正常播放合并后的文件，适合用于下载和离线播放场景。
+
+特别值得注意的是，在代码实现中，我们会处理参数中时间范围与实际录像时间的重叠关系，只提取用户真正需要的内容：
+
+```go
+if i == 0 {
+    startTimestamp := startTime.Sub(stream.StartTime).Milliseconds()
+    var startSample *box.Sample
+    if startSample, err = demuxer.SeekTime(uint64(startTimestamp)); err != nil {
+        tsOffset = 0
+        continue
+    }
+    tsOffset = -int64(startSample.Timestamp)
+}
+
+// 在最后一个文件中，超出结束时间的帧会被跳过
+if i == streamCount-1 && int64(sample.Timestamp) > endTime.Sub(stream.StartTime).Milliseconds() {
+    break
+}
+```
+
+### fMP4合并流程
+
+```mermaid
+sequenceDiagram
+    participant User as 用户
+    participant API as API服务
+    participant DB as 数据库
+    participant MP4s as 多个MP4文件
+    participant Muxer as fMP4封装器
+    participant Output as 输出fMP4文件
+    
+    User->>API: 请求时间范围录像<br>(stream, startTime, endTime)
+    API->>DB: 查询指定范围的录像记录
+    DB-->>API: 返回符合条件的录像列表
+    
+    Muxer->>Output: 写入ftyp box
+    Muxer->>Output: 写入初始moov box<br>(包含mvex)
+    
+    loop 对每个MP4文件
+        API->>MP4s: 读取文件
+        MP4s->>Muxer: 解析文件结构
+        Muxer->>Muxer: 解析轨道信息
+        Muxer->>Muxer: 提取媒体样本
+        
+        loop 对每个样本
+            Note over Muxer: 检查样本是否在目标时间范围内
+            Muxer->>Muxer: 调整时间戳
+            Muxer->>Muxer: 创建moof+mdat对
+            Muxer->>Output: 写入moof+mdat对
+        end
+    end
+    
+    Output-->>User: 向用户提供合并后的文件
+```
+
+fMP4的合并更加灵活，每个样本都被封装成独立的`moof`+`mdat`片段，保持了可独立解码的特性，更有利于流式传输和随机访问。这种方式特别适合与MSE和HLS结合，为实时流媒体播放提供支持，让用户能够在浏览器中直接高效地播放合并后的内容，而无需等待整个文件下载完成。
+
+### 合并中的编解码兼容性处理
+
+在多段录像合并过程中，我们面临的一个关键挑战是处理不同文件可能存在的编码参数差异。例如，在长时间录制过程中，摄像头可能因环境变化调整了视频分辨率，或者编码器可能重新初始化导致编码参数变化。
+
+为了解决这一问题，Monibuca实现了一个智能的轨道版本管理系统，通过比较编码器特定数据(ExtraData)来识别变化：
+
+```mermaid
+sequenceDiagram
+    participant Muxer as 合并器
+    participant Track as 轨道管理器
+    participant History as 轨道历史版本
+
+    loop 对每个新轨道
+        Muxer->>Track: 检查轨道编码参数
+        Track->>History: 比较已有轨道版本
+        alt 发现匹配的轨道版本
+            History-->>Track: 返回现有轨道
+            Track-->>Muxer: 使用已有轨道
+        else 无匹配版本
+            Track->>Track: 创建新轨道版本
+            Track->>History: 添加到历史版本库
+            Track-->>Muxer: 使用新轨道
+        end
+    end
+```
+
+这种设计确保了即使原始录像中存在编码参数变化，合并后的文件也能保持正确的解码参数，为用户提供流畅的播放体验。
+
+### 性能优化
+
+在处理大型视频文件或大量并发请求时，合并过程的性能是一个重要考量。我们采取了以下优化措施：
+
+1. **流式处理**：逐帧处理样本，避免将整个文件加载到内存
+2. **并行处理**：对多个独立任务(如文件解析)采用并行处理
+3. **智能缓存**：缓存常用的编码参数和文件元数据
+4. **按需读取**：仅读取和处理目标时间范围内的样本
+
+这些优化使得系统能够高效处理大规模的录像合并请求，即使是跨越数小时或数天的长时间录像，也能在合理的时间内完成处理。
+
+多段MP4合并功能极大地增强了Monibuca作为流媒体服务器的灵活性和用户体验，使用户能够精确获取所需的录像内容，无论原始录像如何分段存储。
+
+## 媒体源扩展(MSE)与fMP4的兼容实现
+
+### MSE技术概述
+
+媒体源扩展(Media Source Extensions, MSE)是一种JavaScript API，允许网页开发者直接操作媒体流数据。它使得自定义的自适应比特率流媒体播放器可以完全在浏览器中实现，无需依赖外部插件。
+
+MSE的核心工作原理是：
+1. 创建一个MediaSource对象
+2. 创建一个或多个SourceBuffer对象
+3. 将媒体片段追加到SourceBuffer中
+4. 浏览器负责解码和播放这些片段
+
+### fMP4与MSE的完美适配
+
+fMP4格式与MSE有着天然的兼容性，主要体现在：
+
+1. fMP4的每个片段都可以独立解码
+2. 初始化段和媒体段的清晰分离符合MSE的缓冲区管理模型
+3. 时间戳的精确控制使得无缝拼接成为可能
+
+以下时序图展示了fMP4如何与MSE配合工作：
+
+```mermaid
+sequenceDiagram
+    participant Client as 浏览器客户端
+    participant Server as 服务器
+    participant MSE as MediaSource API
+    participant Video as HTML5 Video元素
+    
+    Client->>Video: 创建video元素
+    Client->>MSE: 创建MediaSource对象
+    Client->>Video: 设置video.src = URL.createObjectURL(mediaSource)
+    MSE-->>Client: sourceopen事件
+    
+    Client->>MSE: 创建SourceBuffer
+    Client->>Server: 请求初始化段(ftyp+moov)
+    Server-->>Client: 返回初始化段
+    Client->>MSE: appendBuffer(初始化段)
+    
+    loop 播放过程
+        Client->>Server: 请求媒体段(moof+mdat)
+        Server-->>Client: 返回媒体段
+        Client->>MSE: appendBuffer(媒体段)
+        MSE-->>Video: 解码并渲染帧
+    end
+```
+
+在Monibuca的实现中，我们针对MSE进行了特殊优化：为每一帧创建独立的moof和mdat。这种实现方式尽管会增加一些开销，但提供了极高的灵活性，特别适合于低延迟的实时流媒体场景和精确的帧级操作。
+
+## HLS与fMP4在实际应用中的集成
+
+在实际应用中，我们将fMP4技术与HLS v7协议结合，实现了基于时间范围的点播功能。系统可以根据用户指定的时间范围，从数据库中查找对应的MP4记录，然后生成fMP4格式的HLS播放列表：
+
+```mermaid
+sequenceDiagram
+    participant Client as 客户端
+    participant Server as HLS服务
+    participant DB as 数据库
+    participant MP4Plugin as MP4插件
+    
+    Client->>Server: 请求fMP4.m3u8<br>带时间范围参数
+    Server->>DB: 查询指定时间范围的MP4记录
+    DB-->>Server: 返回记录列表
+    
+    Server->>Server: 创建HLS v7播放列表<br>Version: 7
+    loop 对每个记录
+        Server->>Server: 计算时长
+        Server->>Server: 添加媒体片段URL<br>/mp4/download/{stream}.fmp4?id={id}
+    end
+    
+    Server->>Server: 添加#EXT-X-ENDLIST标记
+    Server-->>Client: 返回HLS播放列表
+    
+    loop 对每个片段
+        Client->>MP4Plugin: 请求fMP4片段
+        MP4Plugin->>MP4Plugin: 转换为fMP4格式
+        MP4Plugin-->>Client: 返回fMP4片段
+    end
+```
+
+通过这种方式，我们在保持兼容现有HLS客户端的同时，利用了fMP4格式的优势，提供了更高效的流媒体服务。
+
+## 结论
+
+fMP4作为一种现代媒体容器格式，结合了MP4的高效压缩和流媒体传输的灵活性，非常适合现代Web应用中的视频分发需求。通过与HLS v7和MSE技术的结合，可以实现更高效、更灵活的流媒体服务。
+
+在Monibuca项目的实践中，我们通过实现MP4到fMP4的转换、多段MP4文件的合并，以及针对MSE优化fMP4片段生成，成功构建了一套完整的流媒体解决方案。这些技术的应用使得我们的系统能够提供更好的用户体验，包括更快的启动时间、更平滑的画质切换以及更低的带宽消耗。
+
+随着视频技术的不断发展，fMP4作为连接传统媒体格式与现代Web技术的桥梁，将继续在流媒体领域发挥重要作用。而Monibuca项目也将持续探索和优化这一技术，为用户提供更优质的流媒体服务。 

doc_CN/stream_alias_usage.md

@@ -0,0 +1,206 @@
+# Monibuca 流别名功能使用指南
+
+## 1. 功能简介
+
+流别名是 Monibuca 提供的一个强大功能，它允许您为同一个流创建多个不同的访问路径。这个功能不仅可以简化流的访问方式，更重要的是能够实现无缝的流内容切换，特别适合直播过程中插入广告等场景。
+
+## 2. 基本使用方法
+
+### 2.1 创建别名
+
+通过 HTTP API 创建别名：
+
+```bash
+curl -X POST http://localhost:8080/api/stream/alias \
+  -H "Content-Type: application/json" \
+  -d '{
+    "streamPath": "live/original",
+    "alias": "live/simple",
+    "autoRemove": false
+  }'
+```
+
+### 2.2 查看当前别名列表
+
+```bash
+curl http://localhost:8080/api/stream/alias
+```
+
+### 2.3 删除别名
+
+```bash
+curl -X POST http://localhost:8080/api/stream/alias \
+  -H "Content-Type: application/json" \
+  -d '{
+    "alias": "live/simple"
+  }'
+```
+
+## 3. 实战案例：直播广告插入
+
+### 3.1 场景描述
+
+在直播过程中，经常需要在适当的时机插入广告。使用流别名功能，我们可以实现：
+- 无缝切换between直播内容和广告
+- 保持观众的持续观看体验
+- 灵活控制广告的插入时机
+- 支持多个广告源的轮换播放
+
+### 3.2 实现步骤
+
+1. **准备工作**
+   ```bash
+   # 假设主直播流的路径为：live/main
+   # 广告流的路径为：ads/ad1
+   ```
+
+2. **创建主直播的别名**
+   ```bash
+   curl -X POST http://localhost:8080/api/stream/alias \
+     -H "Content-Type: application/json" \
+     -d '{
+       "streamPath": "live/main",
+       "alias": "live/show",
+       "autoRemove": false
+     }'
+   ```
+
+3. **需要插入广告时**
+   ```bash
+   # 将别名指向广告流
+   curl -X POST http://localhost:8080/api/stream/alias \
+     -H "Content-Type: application/json" \
+     -d '{
+       "streamPath": "ads/ad1",
+       "alias": "live/show",
+       "autoRemove": false
+     }'
+   ```
+
+4. **广告播放结束后**
+   ```bash
+   # 将别名重新指向主直播流
+   curl -X POST http://localhost:8080/api/stream/alias \
+     -H "Content-Type: application/json" \
+     -d '{
+       "streamPath": "live/main",
+       "alias": "live/show",
+       "autoRemove": false
+     }'
+   ```
+
+### 3.3 效果说明
+
+1. **对观众端的影响**
+   - 观众始终访问 `live/show` 这个固定地址
+   - 切换过程对观众无感知
+   - 不会出现黑屏或卡顿
+   - 无需刷新播放器
+
+2. **对直播系统的影响**
+   - 主播端推流不受影响
+   - 支持多路广告源预加载
+   - 可以实现精确的时间控制
+   - 系统资源占用小
+
+## 4. 进阶使用技巧
+
+### 4.1 广告轮播方案
+
+```bash
+# 创建多个广告流的别名
+curl -X POST http://localhost:8080/api/stream/alias \
+  -H "Content-Type: application/json" \
+  -d '{
+    "streamPath": "ads/ad1",
+    "alias": "ads/current",
+    "autoRemove": true
+  }'
+
+# 通过脚本定时切换不同的广告
+for ad in ad1 ad2 ad3; do
+  curl -X POST http://localhost:8080/api/stream/alias \
+    -H "Content-Type: application/json" \
+    -d "{
+      \"streamPath\": \"ads/$ad\",
+      \"alias\": \"ads/current\",
+      \"autoRemove\": true
+    }"
+  sleep 30  # 每个广告播放30秒
+done
+```
+
+### 4.2 使用自动移除功能
+
+当广告流结束时自动切回主流：
+
+```bash
+curl -X POST http://localhost:8080/api/stream/alias \
+  -H "Content-Type: application/json" \
+  -d '{
+    "streamPath": "ads/ad1",
+    "alias": "live/show",
+    "autoRemove": true
+  }'
+```
+
+### 4.3 条件触发广告
+
+结合 Monibuca 的其他功能，可以实现：
+- 观众数量达到阈值时插入广告
+- 直播时长达到特定值时插入广告
+- 根据直播内容标签触发相关广告
+
+## 5. 最佳实践建议
+
+1. **广告内容预加载**
+   - 提前准备好广告流
+   - 确保广告源的稳定性
+   - 使用缓存机制提高切换速度
+
+2. **合理的切换策略**
+   - 避免频繁切换影响用户体验
+   - 选择适当的切换时机
+   - 保持广告时长的合理控制
+
+3. **监控和统计**
+   - 记录广告播放情况
+   - 监控切换过程是否平滑
+   - 统计观众观看数据
+
+4. **容错处理**
+   - 广告流异常时快速切回主流
+   - 设置合理的超时时间
+   - 做好日志记录
+
+## 6. 常见问题解答
+
+1. **Q: 切换时观众会感知到卡顿吗？**
+   A: 不会。流别名的切换是服务器端的操作，对客户端播放器完全透明。
+
+2. **Q: 如何确保广告按预期时间播放？**
+   A: 可以通过脚本控制切换时间，并配合自动移除功能来确保准确性。
+
+3. **Q: 支持多少个并发的别名？**
+   A: 理论上没有限制，但建议根据服务器资源合理使用。
+
+4. **Q: 如何处理广告流异常的情况？**
+   A: 建议使用自动移除功能，并配合监控系统及时发现和处理异常。
+
+## 7. 注意事项
+
+1. **资源管理**
+   - 及时清理不再使用的别名
+   - 避免创建过多无用的别名
+   - 定期检查别名状态
+
+2. **性能考虑**
+   - 控制并发别名数量
+   - 合理设置缓存策略
+   - 监控服务器资源使用情况
+
+3. **用户体验**
+   - 控制广告频率和时长
+   - 确保切换的流畅性
+   - 考虑不同网络环境的用户
+``` 

example/8080/cascade_server.yaml

@@ -1,13 +1,5 @@
 global:
   loglevel: debug
-  disableall: true
-#console:
-#  secret: 00aea3af031f134d6307618b05ec4899
 cascadeserver:
-  enable: true
   quic:
-    listenaddr: :44944
-#flv:
-#  pull:
-#    pullonstart:
-#      live/test: /Users/dexter/Movies/jb-demo.flv
+    listenaddr: :44944

example/8080/hook.yaml

@@ -0,0 +1,7 @@
+hook:
+  server_keep_alive:
+    url: "http://your-webhook-endpoint"
+    method: "POST"
+    interval: 60  # 每60秒发送一次保活信息
+    retryTimes: 3
+    retryInterval: 1s

example/8080/pull_mp4_file.yaml

@@ -7,4 +7,9 @@ rtsp:
 mp4:
   enable: true
   pull:
-    live/test: /Users/dexter/Movies/test.mp4
+    live/test: /Users/dexter/Movies/test.mp4
+rtmp:
+  enable: true
+
+debug:
+  enable: true

example/8080/snap.yaml

@@ -0,0 +1,17 @@
+snap:
+  onpub:
+    transform:
+      .+:
+        output:
+          - conf:
+              watermark:
+                text: "abcd"              # 水印文字内容
+                fontpath: /Users/dexter/Library/Fonts/MapleMono-NF-CN-Medium.ttf          # 水印字体文件路径
+                fontcolor: "rgba(255,165,0,1)" # 水印字体颜色，支持rgba格式
+                fontsize: 36          # 水印字体大小
+                offsetx: 0           # 水印位置X偏移
+                offsety: 0           # 水印位置Y偏移
+              timeinterval: 1s   # 截图时间间隔
+              savepath: "snaps"  # 截图保存路径
+              iframeinterval: 3  # 间隔多少帧截图
+              querytimedelta: 3  # 查询截图时允许的最大时间差（秒）

example/8081/cascade_client.yaml

@@ -1,15 +1,14 @@
 global:
-  # loglevel: debug
-  http:
-    listenaddr: :8081
-    listenaddrtls: :8555
-  tcp:
-    listenaddr: :50052
+  loglevel: debug
+  disableall: true
+  http: :8081
+  tcp: :50052
 cascadeclient:
+  enable: true
   server: localhost:44944
-  pull:
-    enableregexp: true
-    pullonsub:
+  secret: dexter
+  onsub:
+    pull:
       .*: m7s://$0
-#console:
-#  secret: de2c0bb9fd47684adc07a426e139239b
+flv:
+  enable: true

example/8081/default.yaml

@@ -0,0 +1,13 @@
+global:
+  loglevel: debug
+  http:
+    listenaddr: :8081
+    listenaddrtls: :8555
+  tcp:
+    listenaddr: :50052
+rtsp:
+  enable: false
+rtmp:
+  tcp: :1936
+webrtc:
+  port: udp:9000-9100

example/8081/rtsp_server.yaml

@@ -0,0 +1,12 @@
+global:
+  loglevel: debug
+  tcp: :50052
+  http: :8081
+  disableall: true
+flv:
+  enable: true
+  pull:
+    live/test: /Users/dexter/Movies/jb-demo.flv
+rtsp:
+  enable: true
+  tcp: :8554

example/8081/transcode.yaml

@@ -9,7 +9,7 @@ transcode:
     transform:
      ^live.+:
        input:
-         mode: rtsp
+         mode: pipe
        output:
          - target: rtmp://localhost/trans/$0/small
            conf: -loglevel debug -c:a aac -c:v h264 -vf scale=320:240

example/custom/main.go

@@ -4,12 +4,15 @@ import (
 	"context"
 	"flag"
 	"fmt"
+	"path/filepath"
+	"strings"
+	"time"
+
 	"m7s.live/v5"
 	_ "m7s.live/v5/plugin/debug"
 	_ "m7s.live/v5/plugin/flv"
 	_ "m7s.live/v5/plugin/gb28181"
 	_ "m7s.live/v5/plugin/logrotate"
-	_ "m7s.live/v5/plugin/monitor"
 	_ "m7s.live/v5/plugin/mp4"
 	mp4 "m7s.live/v5/plugin/mp4/pkg"
 	_ "m7s.live/v5/plugin/preview"
@@ -17,24 +20,21 @@ import (
 	_ "m7s.live/v5/plugin/rtsp"
 	_ "m7s.live/v5/plugin/sei"
 	_ "m7s.live/v5/plugin/srt"
-	_ "m7s.live/v5/plugin/stress"
+	_ "m7s.live/v5/plugin/test"
 	_ "m7s.live/v5/plugin/transcode"
 	_ "m7s.live/v5/plugin/webrtc"
-	"path/filepath"
-	"strings"
-	"time"
 )
 
 func main() {
 	conf := flag.String("c", "config.yaml", "config file")
 	flag.Parse()
 	mp4.CustomFileName = func(job *m7s.RecordJob) string {
-		if job.Fragment == 0 {
-			return job.FilePath + ".mp4"
+		if job.RecConf.Fragment == 0 {
+			return job.RecConf.FilePath + ".mp4"
 		}
 		ss := strings.Split(job.StreamPath, "/")
 		lastPart := ss[len(ss)-1]
-		return filepath.Join(job.FilePath, fmt.Sprintf("%s_%s%s", lastPart, time.Now().Local().Format("2006-01-02-15-04-05"), ".mp4"))
+		return filepath.Join(job.RecConf.FilePath, fmt.Sprintf("%s_%s%s", lastPart, time.Now().Local().Format("2006-01-02-15-04-05"), ".mp4"))
 	}
 	// ctx, _ := context.WithDeadline(context.Background(), time.Now().Add(time.Second*100))
 	m7s.Run(context.Background(), *conf)

example/default/config.yaml

@@ -1,38 +1,162 @@
 global:
+  location:
+    "^/hdl/(.*)": "/flv/$1" # 兼容 v4
+    "^/stress/api/(.*)": "/test/api/stress/$1" # 5.0.x
+    "^/monitor/(.*)": "/debug/$1" # 5.0.x
   loglevel: debug
-  # db:
-  #   dbtype: mysql
-  #   dsn: root:Monibuca#!4@tcp(sh-cynosdbmysql-grp-kxt43lv6.sql.tencentcdb.com:28520)/lkm7s_v5?parseTime=true
+  admin:
+    enablelogin: false
+  # pullproxy:
+  #   - id: 1                        # 唯一ID标识，必须大于0
+  #     name: "camera-1"             # 拉流代理名称
+  #     type: "rtmp"                 # 拉流协议类型
+  #     pull:
+  #       url: "rtmp://example.com/live/stream1"  # 拉流源地址
+  #     streampath: "live/camera1"   # 在Monibuca中的流路径
+  #     pullonstart: true            # 是否在启动时自动开始拉流
+  #     description: "前门摄像头"     # 描述信息
+ 
+debug:
+  enableTaskHistory: true #是否启用任务历史记录
 srt:
   listenaddr: :6000
-  passphrase: foobarfoobar
+  # passphrase: foobarfoobar
 gb28181:
-  autoinvite: true
+  enable: false # 是否启用GB28181协议
+  autoinvite: false #建议使用false，开启后会自动邀请设备推流
+  mediaip: 192.168.1.21 #流媒体收流IP,外网情况下使用公网IP,内网情况下使用网卡IP,不要用127.0.0.1
+  sipip: 192.168.1.21 #SIP通讯IP,不管公网还是内网都使用本机网卡IP,不要用127.0.0.1
   sip:
     listenaddr:
-          - udp::5060
+      - udp::5060
   onsub:
     pull:
-      .* : $0
+      ^\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:
-  publish:
-    delayclosetimeout: 3s
-
+  # enable: false
+  # publish:
+  #   delayclosetimeout: 3s
+  # onpub:
+  #   record:
+  #     ^live/.+:
+  #         fragment: 10s
+  #         filepath: record/$0
+  #         storage:
+  #           s3:
+  #             endpoint: "storage-dev.xiding.tech"
+  #             accessKeyId: "xidinguser"
+  #             secretAccessKey: "U2FsdGVkX1/7uyvj0trCzSNFsfDZ66dMSAEZjNlvW1c="
+  #             bucket: "vidu-media-bucket"
+  #             pathPrefix: ""
+  #             forcePathStyle: true
+  #             useSSL: true
+  # pull:
+  #   live/test: /Users/dexter/Movies/1744963190.mp4
   onsub:
     pull:
-      ^vod/(.+)$: $1
+      ^vod_mp4_\d+/(.+)$: $1
+cascadeserver:
+  quic:
+    listenaddr: :44944
 # llhls:
 #   onpub:
 #     transform:
 #       .* : 1s x 7
-# flv:
+flv:
+  # onpub:
+  #   record:
+  #     ^live/.+:
+  #         fragment: 1m
+  #         filepath: record/$0
+  publish:
+    delayclosetimeout: 3s
+  onsub:
+    pull:
+      ^vod_flv_\d+/(.+)$: $1
 #   pull:
 #     live/test: https://livecb.alicdn.com/mediaplatform/afb241b3-408c-42dd-b665-04d22b64f9df.flv?auth_key=1734575216-0-0-c62721303ce751c8e5b2c95a2ec242a0&F=pc&source=34675810_null_live_detail&ali_flv_retain=2
-# hls:
+hls:
+  # onsub:
+  #   pull:
+  #     ^vod_hls_\d+/(.+)$: $1
+  # pull:
+  #   live/test: https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_4x3/gear3/prog_index.m3u8
 #   onpub:
 #     transform:
 #       .* : 5s x 3
+webrtc:
+  port: udp:9000-9100
+  # onpub:
+  #   push:
+  #     .*: http://localhost:8081/webrtc/push/$0
+
 rtsp:
-#  pull:
-    # live/test: rtsp://admin:1qaz2wsx3EDC@giroro.tpddns.cn:1554/Streaming/Channels/101
-#    live/test: rtsp://admin:1qaz2wsx3EDC@localhost:8554/live/test
+  # pull:
+  # live/test: rtsp://admin:1qaz2wsx3EDC@58.212.158.30/Streaming/Channels/101
+  # live/test: rtsp://admin:1qaz2wsx3EDC@localhost:8554/live/test
+# webrtc:
+#   publish:
+#     pubaudio: false
+#   port: udp:9000-9100
+snap:
+  enable: false
+  onpub:
+    transform:
+      .+:
+        output:
+          - 
+            conf:
+              watermark:
+                text: "abcd" # 水印文字内容
+                fontpath: /Users/dexter/Library/Fonts/MapleMono-NF-CN-Medium.ttf # 水印字体文件路径
+                fontcolor: "rgba(255,165,0,1)" # 水印字体颜色，支持rgba格式
+                fontsize: 36 # 水印字体大小
+                offsetx: 0 # 水印位置X偏移
+                offsety: 0 # 水印位置Y偏移
+              timeinterval: 1s # 截图时间间隔
+              savepath: "snaps" # 截图保存路径
+              iframeinterval: 3 # 间隔多少帧截图
+              querytimedelta: 3 # 查询截图时允许的最大时间差（秒）
+onvif:
+  enable: false
+  discoverinterval: 3 # 发现设备的间隔，单位秒，默认30秒，建议比rtsp插件的重连间隔大点
+  autopull: true
+  autoadd: true
+  interfaces: # 设备发现指定网卡，以及该网卡对应IP段的全局默认账号密码，支持多网卡
+    - interfacename: 以太网 # 网卡名称 或者"以太网" "eth0"等，使用ipconfig 或者 ifconfig 查看网卡名称
+      username: admin # onvif 账号
+      password: admin # onvif 密码
+    # - interfacename: WLAN 2 # 网卡2
+    #   username: admin
+    #   password: admin
+  # devices: # 可以给指定设备配置单独的密码
+  #   - ip: 192.168.1.1
+  #     username: admin
+  #     password: '123'
+  #   - ip: 192.168.1.2
+  #     username: admin
+  #     password: '456'

example/default/main.go

@@ -5,21 +5,26 @@ import (
 	"flag"
 
 	"m7s.live/v5"
+	_ "m7s.live/v5/plugin/cascade"
+
 	_ "m7s.live/v5/plugin/debug"
 	_ "m7s.live/v5/plugin/flv"
 	_ "m7s.live/v5/plugin/gb28181"
 	_ "m7s.live/v5/plugin/hls"
 	_ "m7s.live/v5/plugin/logrotate"
-	_ "m7s.live/v5/plugin/monitor"
 	_ "m7s.live/v5/plugin/mp4"
+	_ "m7s.live/v5/plugin/onvif"
 	_ "m7s.live/v5/plugin/preview"
 	_ "m7s.live/v5/plugin/rtmp"
+	_ "m7s.live/v5/plugin/rtp"
 	_ "m7s.live/v5/plugin/rtsp"
 	_ "m7s.live/v5/plugin/sei"
+	_ "m7s.live/v5/plugin/snap"
 	_ "m7s.live/v5/plugin/srt"
-	_ "m7s.live/v5/plugin/stress"
+	_ "m7s.live/v5/plugin/test"
 	_ "m7s.live/v5/plugin/transcode"
 	_ "m7s.live/v5/plugin/webrtc"
+	_ "m7s.live/v5/plugin/webtransport"
 )
 
 func main() {

example/multiple/main.go

@@ -3,15 +3,15 @@ package main
 import (
 	"context"
 	"flag"
+
 	"m7s.live/v5"
 	_ "m7s.live/v5/plugin/cascade"
 	_ "m7s.live/v5/plugin/debug"
 	_ "m7s.live/v5/plugin/flv"
 	_ "m7s.live/v5/plugin/logrotate"
-	_ "m7s.live/v5/plugin/monitor"
 	_ "m7s.live/v5/plugin/rtmp"
 	_ "m7s.live/v5/plugin/rtsp"
-	_ "m7s.live/v5/plugin/stress"
+	_ "m7s.live/v5/plugin/test"
 	_ "m7s.live/v5/plugin/webrtc"
 )
 

example/qiaopin/main.go

@@ -16,7 +16,6 @@ import (
 	_ "m7s.live/v5/plugin/flv"
 	_ "m7s.live/v5/plugin/gb28181"
 	_ "m7s.live/v5/plugin/logrotate"
-	_ "m7s.live/v5/plugin/monitor"
 	_ "m7s.live/v5/plugin/mp4"
 	mp4 "m7s.live/v5/plugin/mp4/pkg"
 	_ "m7s.live/v5/plugin/preview"
@@ -24,7 +23,7 @@ import (
 	_ "m7s.live/v5/plugin/rtsp"
 	_ "m7s.live/v5/plugin/sei"
 	_ "m7s.live/v5/plugin/srt"
-	_ "m7s.live/v5/plugin/stress"
+	_ "m7s.live/v5/plugin/test"
 	_ "m7s.live/v5/plugin/transcode"
 	_ "m7s.live/v5/plugin/webrtc"
 )
@@ -72,7 +71,7 @@ func main() {
 
 	mp4.CustomFileName = func(job *m7s.RecordJob) string {
 
-		fileDir := strings.ReplaceAll(job.FilePath, job.StreamPath, "")
+		fileDir := strings.ReplaceAll(job.RecConf.FilePath, job.StreamPath, "")
 		if err := os.MkdirAll(fileDir, 0755); err != nil {
 			log.Default().Printf("创建目录失败：%s", err)
 			return fmt.Sprintf("%s_%s%s", job.StreamPath, time.Now().Local().Format("2006-01-02-15-04-05"), ".mp4")

example/test/config.yaml

@@ -0,0 +1,2 @@
+global:
+  log_level: debug

example/test/main.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+
+	"m7s.live/v5"
+	_ "m7s.live/v5/plugin/cascade"
+
+	_ "m7s.live/v5/plugin/debug"
+	_ "m7s.live/v5/plugin/flv"
+	_ "m7s.live/v5/plugin/gb28181"
+	_ "m7s.live/v5/plugin/hls"
+	_ "m7s.live/v5/plugin/logrotate"
+	_ "m7s.live/v5/plugin/mp4"
+	_ "m7s.live/v5/plugin/onvif"
+	_ "m7s.live/v5/plugin/preview"
+	_ "m7s.live/v5/plugin/rtmp"
+	_ "m7s.live/v5/plugin/rtp"
+	_ "m7s.live/v5/plugin/rtsp"
+	_ "m7s.live/v5/plugin/sei"
+	_ "m7s.live/v5/plugin/snap"
+	_ "m7s.live/v5/plugin/srt"
+	_ "m7s.live/v5/plugin/test"
+	_ "m7s.live/v5/plugin/transcode"
+	_ "m7s.live/v5/plugin/webrtc"
+	_ "m7s.live/v5/plugin/webtransport"
+)
+
+func main() {
+	conf := flag.String("c", "config.yaml", "config file")
+	flag.Parse()
+	// ctx, _ := context.WithDeadline(context.Background(), time.Now().Add(time.Second*100))
+	err := m7s.Run(context.Background(), *conf)
+	fmt.Println(err)
+}

example/xdp/main.go

@@ -1,126 +0,0 @@
-// Copyright 2019 Asavie Technologies Ltd. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style license
-// that can be found in the LICENSE file in the root of the source
-// tree.
-
-/*
-dumpframes demostrates how to receive frames from a network link using
-github.com/asavie/xdp package, it sets up an XDP socket attached to a
-particular network link and dumps all frames it receives to standard output.
-*/
-package main
-
-import (
-	"encoding/hex"
-	"flag"
-	"fmt"
-	"log"
-	"net"
-
-	"github.com/asavie/xdp"
-	"github.com/asavie/xdp/examples/dumpframes/ebpf"
-	"github.com/google/gopacket"
-	"github.com/google/gopacket/layers"
-)
-
-func main() {
-	var linkName string
-	var queueID int
-	var protocol int64
-
-	log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds)
-
-	flag.StringVar(&linkName, "linkname", "enp3s0", "The network link on which rebroadcast should run on.")
-	flag.IntVar(&queueID, "queueid", 0, "The ID of the Rx queue to which to attach to on the network link.")
-	flag.Int64Var(&protocol, "ip-proto", 0, "If greater than 0 and less than or equal to 255, limit xdp bpf_redirect_map to packets with the specified IP protocol number.")
-	flag.Parse()
-
-	interfaces, err := net.Interfaces()
-	if err != nil {
-		fmt.Printf("error: failed to fetch the list of network interfaces on the system: %v\n", err)
-		return
-	}
-
-	Ifindex := -1
-	for _, iface := range interfaces {
-		if iface.Name == linkName {
-			Ifindex = iface.Index
-			break
-		}
-	}
-	if Ifindex == -1 {
-		fmt.Printf("error: couldn't find a suitable network interface to attach to\n")
-		return
-	}
-
-	var program *xdp.Program
-
-	// Create a new XDP eBPF program and attach it to our chosen network link.
-	if protocol == 0 {
-		program, err = xdp.NewProgram(queueID + 1)
-	} else {
-		program, err = ebpf.NewIPProtoProgram(uint32(protocol), nil)
-	}
-	if err != nil {
-		fmt.Printf("error: failed to create xdp program: %v\n", err)
-		return
-	}
-	defer program.Close()
-	if err := program.Attach(Ifindex); err != nil {
-		fmt.Printf("error: failed to attach xdp program to interface: %v\n", err)
-		return
-	}
-	defer program.Detach(Ifindex)
-
-	// Create and initialize an XDP socket attached to our chosen network
-	// link.
-	xsk, err := xdp.NewSocket(Ifindex, queueID, nil)
-	if err != nil {
-		fmt.Printf("error: failed to create an XDP socket: %v\n", err)
-		return
-	}
-
-	// Register our XDP socket file descriptor with the eBPF program so it can be redirected packets
-	if err := program.Register(queueID, xsk.FD()); err != nil {
-		fmt.Printf("error: failed to register socket in BPF map: %v\n", err)
-		return
-	}
-	defer program.Unregister(queueID)
-
-	for {
-		// If there are any free slots on the Fill queue...
-		if n := xsk.NumFreeFillSlots(); n > 0 {
-			// ...then fetch up to that number of not-in-use
-			// descriptors and push them onto the Fill ring queue
-			// for the kernel to fill them with the received
-			// frames.
-			xsk.Fill(xsk.GetDescs(n, true))
-		}
-
-		// Wait for receive - meaning the kernel has
-		// produced one or more descriptors filled with a received
-		// frame onto the Rx ring queue.
-		log.Printf("waiting for frame(s) to be received...")
-		numRx, _, err := xsk.Poll(-1)
-		if err != nil {
-			fmt.Printf("error: %v\n", err)
-			return
-		}
-
-		if numRx > 0 {
-			// Consume the descriptors filled with received frames
-			// from the Rx ring queue.
-			rxDescs := xsk.Receive(numRx)
-
-			// Print the received frames and also modify them
-			// in-place replacing the destination MAC address with
-			// broadcast address.
-			for i := 0; i < len(rxDescs); i++ {
-				pktData := xsk.GetFrame(rxDescs[i])
-				pkt := gopacket.NewPacket(pktData, layers.LayerTypeEthernet, gopacket.Default)
-				log.Printf("received frame:\n%s%+v", hex.Dump(pktData[:]), pkt)
-			}
-		}
-	}
-}

go.mod

@@ -1,46 +1,57 @@
 module m7s.live/v5
 
-go 1.23
+go 1.23.0
 
 require (
-	github.com/Eyevinn/mp4ff v0.45.1
 	github.com/VictoriaMetrics/VictoriaMetrics v1.102.0
-	github.com/asavie/xdp v0.3.3
+	github.com/aliyun/aliyun-oss-go-sdk v3.0.2+incompatible
+	github.com/aws/aws-sdk-go v1.55.7
+	github.com/beevik/etree v1.4.1
 	github.com/bluenviron/gohlslib v1.4.0
 	github.com/c0deltin/duckdb-driver v0.1.0
-	github.com/cilium/ebpf v0.15.0
 	github.com/cloudwego/goref v0.0.0-20240724113447-685d2a9523c8
 	github.com/deepch/vdk v0.0.27
-	github.com/emiago/sipgo v0.22.0
+	github.com/disintegration/imaging v1.6.2
+	github.com/emiago/sipgo v1.0.0-alpha
 	github.com/go-delve/delve v1.23.0
 	github.com/gobwas/ws v1.3.2
-	github.com/google/gopacket v1.1.19
+	github.com/golang-jwt/jwt/v5 v5.2.3
+	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0
+	github.com/google/uuid v1.6.0
 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.19.1
 	github.com/husanpao/ip v0.0.0-20220711082147-73160bb611a8
-	github.com/icholy/digest v0.1.22
+	github.com/icholy/digest v1.1.0
+	github.com/jinzhu/copier v0.4.0
+	github.com/kerberos-io/onvif v1.0.0
+	github.com/langhuihui/gotask v1.0.2
+	github.com/mark3labs/mcp-go v0.27.0
 	github.com/mattn/go-sqlite3 v1.14.24
 	github.com/mcuadros/go-defaults v1.2.0
-	github.com/ncruces/go-sqlite3 v0.18.1
-	github.com/ncruces/go-sqlite3/gormlite v0.18.0
-	github.com/pion/interceptor v0.1.29
-	github.com/pion/logging v0.2.2
-	github.com/pion/rtcp v1.2.14
-	github.com/pion/rtp v1.8.6
-	github.com/pion/sdp/v3 v3.0.9
-	github.com/pion/webrtc/v3 v3.2.12
-	github.com/quic-go/quic-go v0.43.1
-	github.com/rs/zerolog v1.33.0
+	github.com/mozillazg/go-pinyin v0.20.0
+	github.com/ncruces/go-sqlite3 v0.27.1
+	github.com/ncruces/go-sqlite3/gormlite v0.24.0
+	github.com/pion/interceptor v0.1.40
+	github.com/pion/logging v0.2.4
+	github.com/pion/rtcp v1.2.15
+	github.com/pion/rtp v1.8.21
+	github.com/pion/sdp/v3 v3.0.15
+	github.com/pion/webrtc/v4 v4.1.4
+	github.com/quic-go/qpack v0.5.1
+	github.com/quic-go/quic-go v0.50.1
 	github.com/samber/slog-common v0.17.1
 	github.com/shirou/gopsutil/v4 v4.24.8
-	github.com/vishvananda/netlink v1.1.0
+	github.com/stretchr/testify v1.10.0
+	github.com/tencentyun/cos-go-sdk-v5 v0.7.69
+	github.com/valyala/fasthttp v1.61.0
 	github.com/yapingcat/gomedia v0.0.0-20240601043430-920523f8e5c7
-	golang.org/x/text v0.17.0
+	golang.org/x/image v0.22.0
+	golang.org/x/text v0.27.0
 	google.golang.org/genproto/googleapis/api v0.0.0-20240711142825-46eb208f015d
 	google.golang.org/grpc v1.65.0
 	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 (
@@ -49,6 +60,7 @@ require (
 	github.com/VictoriaMetrics/metrics v1.35.1 // indirect
 	github.com/VictoriaMetrics/metricsql v0.76.0 // indirect
 	github.com/abema/go-mp4 v1.2.0 // indirect
+	github.com/andybalholm/brotli v1.1.1 // indirect
 	github.com/asticode/go-astikit v0.30.0 // indirect
 	github.com/asticode/go-astits v1.13.0 // indirect
 	github.com/benburkert/openpgp v0.0.0-20160410205803-c2471f86866c // indirect
@@ -56,13 +68,17 @@ require (
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/chromedp/cdproto v0.0.0-20240202021202-6d0b6a386732 // indirect
 	github.com/chromedp/sysutil v1.0.0 // indirect
+	github.com/cilium/ebpf v0.15.0 // indirect
+	github.com/clbanning/mxj v1.8.4 // indirect
+	github.com/clbanning/mxj/v2 v2.7.0 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+	github.com/elgs/gostrgen v0.0.0-20220325073726-0c3e00d082f6 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
 	github.com/go-sql-driver/mysql v1.7.0 // indirect
 	github.com/gobwas/httphead v0.1.0 // indirect
 	github.com/gobwas/pool v0.2.1 // indirect
 	github.com/golang/snappy v0.0.4 // indirect
-	github.com/google/uuid v1.6.0 // indirect
+	github.com/google/go-querystring v1.0.0 // indirect
 	github.com/hashicorp/golang-lru v1.0.2 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
@@ -70,39 +86,39 @@ require (
 	github.com/jackc/puddle/v2 v2.2.1 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
+	github.com/jmespath/go-jmespath v0.4.0 // indirect
 	github.com/josharian/intern v1.0.0 // indirect
-	github.com/klauspost/compress v1.17.9 // indirect
+	github.com/juju/errors v1.0.0 // indirect
+	github.com/klauspost/compress v1.18.0 // indirect
 	github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 // indirect
 	github.com/mailru/easyjson v0.7.7 // indirect
 	github.com/marcboeker/go-duckdb v1.0.5 // indirect
-	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/mozillazg/go-httpheader v0.2.1 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/ncruces/julianday v1.0.0 // indirect
-	github.com/pion/datachannel v1.5.6 // indirect
-	github.com/pion/dtls/v2 v2.2.11 // indirect
-	github.com/pion/ice/v2 v2.3.9 // indirect
-	github.com/pion/mdns v0.0.12 // indirect
+	github.com/pion/datachannel v1.5.10 // indirect
+	github.com/pion/dtls/v3 v3.0.7 // indirect
+	github.com/pion/ice/v4 v4.0.10 // indirect
+	github.com/pion/mdns/v2 v2.0.7 // indirect
 	github.com/pion/randutil v0.1.0 // indirect
-	github.com/pion/sctp v1.8.16 // indirect
-	github.com/pion/srtp/v2 v2.0.15 // indirect
-	github.com/pion/stun v0.6.1 // indirect
-	github.com/pion/transport/v2 v2.2.5 // indirect
-	github.com/pion/turn/v2 v2.1.2 // indirect
+	github.com/pion/sctp v1.8.39 // indirect
+	github.com/pion/srtp/v3 v3.0.7 // indirect
+	github.com/pion/stun/v3 v3.0.0 // indirect
+	github.com/pion/transport/v3 v3.0.7 // indirect
+	github.com/pion/turn/v4 v4.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c // indirect
 	github.com/prometheus/client_model v0.6.1 // indirect
 	github.com/prometheus/common v0.55.0 // indirect
 	github.com/prometheus/procfs v0.15.1 // indirect
-	github.com/rogpeppe/go-internal v1.12.0 // indirect
 	github.com/samber/lo v1.44.0 // indirect
-	github.com/satori/go.uuid v1.2.1-0.20181028125025-b2ce2384e17b // indirect
 	github.com/shoenig/go-m1cpu v0.1.6 // indirect
 	github.com/sirupsen/logrus v1.9.3 // indirect
-	github.com/stretchr/testify v1.9.0 // indirect
-	github.com/tetratelabs/wazero v1.8.0 // indirect
+	github.com/spf13/cast v1.7.1 // indirect
+	github.com/tetratelabs/wazero v1.9.0 // indirect
 	github.com/tklauser/go-sysconf v0.3.12 // indirect
 	github.com/tklauser/numcpus v0.6.1 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
@@ -111,10 +127,12 @@ require (
 	github.com/valyala/gozstd v1.21.1 // indirect
 	github.com/valyala/histogram v1.2.0 // indirect
 	github.com/valyala/quicktemplate v1.8.0 // indirect
-	github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df // indirect
+	github.com/wlynxg/anet v0.0.5 // indirect
+	github.com/yosida95/uritemplate/v3 v3.0.2 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
-	golang.org/x/arch v0.6.0 // indirect
-	golang.org/x/sync v0.8.0 // indirect
+	golang.org/x/arch v0.8.0 // indirect
+	golang.org/x/sync v0.16.0 // indirect
+	golang.org/x/time v0.5.0 // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20240711142825-46eb208f015d // indirect
 )
 
@@ -126,16 +144,18 @@ require (
 	github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect
 	github.com/google/pprof v0.0.0-20240409012703-83162a5b38cd // indirect
 	github.com/gorilla/websocket v1.5.1
+	github.com/ianlancetaylor/demangle v0.0.0-20240912202439-0a2b6291aafd
+	github.com/langhuihui/gomem v0.0.0-20251001011839-023923cf7683
 	github.com/onsi/ginkgo/v2 v2.9.5 // indirect
 	github.com/phsym/console-slog v0.3.1
 	github.com/prometheus/client_golang v1.20.4
 	github.com/quangngotan95/go-m3u8 v0.1.0
-	go.uber.org/mock v0.4.0 // indirect
-	golang.org/x/crypto v0.26.0 // indirect
-	golang.org/x/exp v0.0.0-20240716175740-e3f259677ff7 // indirect
-	golang.org/x/mod v0.19.0 // indirect
-	golang.org/x/net v0.27.0
-	golang.org/x/sys v0.25.0
-	golang.org/x/tools v0.23.0 // indirect
+	go.uber.org/mock v0.5.0 // indirect
+	golang.org/x/crypto v0.40.0
+	golang.org/x/exp v0.0.0-20240716175740-e3f259677ff7
+	golang.org/x/mod v0.25.0 // indirect
+	golang.org/x/net v0.41.0
+	golang.org/x/sys v0.34.0 // indirect
+	golang.org/x/tools v0.34.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1
 )

go.sum

@@ -1,5 +1,3 @@
-github.com/Eyevinn/mp4ff v0.45.1 h1:Hlx8ZUu8agN7XrHVcZAGIa+dVZ0UW/g/SLv63Pm/+w0=
-github.com/Eyevinn/mp4ff v0.45.1/go.mod h1:hJNUUqOBryLAzUW9wpCJyw2HaI+TCd2rUPhafoS5lgg=
 github.com/VictoriaMetrics/VictoriaMetrics v1.102.0 h1:eRi6VGT7ntLG/OW8XTWUYhSvA+qGD3FHaRkzdgYHOOw=
 github.com/VictoriaMetrics/VictoriaMetrics v1.102.0/go.mod h1:QZhCsD2l+S+BHTdspVSsE4oiFhdKzgVziSy5Q/FZHcs=
 github.com/VictoriaMetrics/easyproto v0.1.4 h1:r8cNvo8o6sR4QShBXQd1bKw/VVLSQma/V2KhTBPf+Sc=
@@ -15,14 +13,20 @@ github.com/abema/go-mp4 v1.2.0 h1:gi4X8xg/m179N/J15Fn5ugywN9vtI6PLk6iLldHGLAk=
 github.com/abema/go-mp4 v1.2.0/go.mod h1:vPl9t5ZK7K0x68jh12/+ECWBCXoWuIDtNgPtU2f04ws=
 github.com/alchemy/rotoslog v0.2.2 h1:yzAOjaQBKgJvAdPi0sF5KSPMq5f2vNJZEnPr73CPDzQ=
 github.com/alchemy/rotoslog v0.2.2/go.mod h1:pOHF0DKryPLaQzjcUlidLVRTksvk9yW75YIu1yYiiEQ=
+github.com/aliyun/aliyun-oss-go-sdk v3.0.2+incompatible h1:8psS8a+wKfiLt1iVDX79F7Y6wUM49Lcha2FMXt4UM8g=
+github.com/aliyun/aliyun-oss-go-sdk v3.0.2+incompatible/go.mod h1:T/Aws4fEfogEE9v+HPhhw+CntffsBHJ8nXQCwKr0/g8=
 github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156 h1:eMwmnE/GDgah4HI848JfFxHt+iPb26b4zyfspmqY0/8=
 github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM=
-github.com/asavie/xdp v0.3.3 h1:b5Aa3EkMJYBeUO5TxPTIAa4wyUqYcsQr2s8f6YLJXhE=
-github.com/asavie/xdp v0.3.3/go.mod h1:Vv5p+3mZiDh7ImdSvdon3E78wXyre7df5V58ATdIYAY=
+github.com/andybalholm/brotli v1.1.1 h1:PR2pgnyFznKEugtsUo0xLdDop5SKXd5Qf5ysW+7XdTA=
+github.com/andybalholm/brotli v1.1.1/go.mod h1:05ib4cKhjx3OQYUY22hTVd34Bc8upXjOLL2rKwwZBoA=
 github.com/asticode/go-astikit v0.30.0 h1:DkBkRQRIxYcknlaU7W7ksNfn4gMFsB0tqMJflxkRsZA=
 github.com/asticode/go-astikit v0.30.0/go.mod h1:h4ly7idim1tNhaVkdVBeXQZEE3L0xblP7fCWbgwipF0=
 github.com/asticode/go-astits v1.13.0 h1:XOgkaadfZODnyZRR5Y0/DWkA9vrkLLPLeeOvDwfKZ1c=
 github.com/asticode/go-astits v1.13.0/go.mod h1:QSHmknZ51pf6KJdHKZHJTLlMegIrhega3LPWz3ND/iI=
+github.com/aws/aws-sdk-go v1.55.7 h1:UJrkFq7es5CShfBwlWAC8DA077vp8PyVbQd3lqLiztE=
+github.com/aws/aws-sdk-go v1.55.7/go.mod h1:eRwEWoyTWFMVYVQzKMNHWP5/RV4xIUGMQfXQHfHkpNU=
+github.com/beevik/etree v1.4.1 h1:PmQJDDYahBGNKDcpdX8uPy1xRCwoCGVUiW669MEirVI=
+github.com/beevik/etree v1.4.1/go.mod h1:gPNJNaBGVZ9AwsidazFZyygnd+0pAU38N4D+WemwKNs=
 github.com/benburkert/openpgp v0.0.0-20160410205803-c2471f86866c h1:8XZeJrs4+ZYhJeJ2aZxADI2tGADS15AzIF8MQ8XAhT4=
 github.com/benburkert/openpgp v0.0.0-20160410205803-c2471f86866c/go.mod h1:x1vxHcL/9AVzuk5HOloOEPrtJY0MaalYr78afXZ+pWI=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
@@ -42,12 +46,14 @@ github.com/chromedp/chromedp v0.9.5 h1:viASzruPJOiThk7c5bueOUY91jGLJVximoEMGoH93
 github.com/chromedp/chromedp v0.9.5/go.mod h1:D4I2qONslauw/C7INoCir1BJkSwBYMyZgx8X276z3+Y=
 github.com/chromedp/sysutil v1.0.0 h1:+ZxhTpfpZlmchB58ih/LBHX52ky7w2VhQVKQMucy3Ic=
 github.com/chromedp/sysutil v1.0.0/go.mod h1:kgWmDdq8fTzXYcKIBqIYvRRTnYb9aNS9moAV0xufSww=
-github.com/cilium/ebpf v0.4.0/go.mod h1:4tRaxcgiL706VnOzHOdBlY8IEAIdxINsQBcU4xJJXRs=
 github.com/cilium/ebpf v0.15.0 h1:7NxJhNiBT3NG8pZJ3c+yfrVdHY8ScgKD27sScgjLMMk=
 github.com/cilium/ebpf v0.15.0/go.mod h1:DHp1WyrLeiBh19Cf/tfiSMhqheEiK8fXFZ4No0P1Hso=
+github.com/clbanning/mxj v1.8.4 h1:HuhwZtbyvyOw+3Z1AowPkU87JkJUSv751ELWaiTpj8I=
+github.com/clbanning/mxj v1.8.4/go.mod h1:BVjHeAH+rl9rs6f+QIpeRl0tfu10SXn1pUSa5PVGJng=
+github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyME=
+github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/cloudwego/goref v0.0.0-20240724113447-685d2a9523c8 h1:K7L7KFg5siEysLit42Bf7n4qNRkGxniPeBtmpsxsfdQ=
 github.com/cloudwego/goref v0.0.0-20240724113447-685d2a9523c8/go.mod h1:IMGV1p8Mw3uyZYClI5bA8uqk8LGr/MYFv92V0m88XUk=
-github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
 github.com/creack/pty v1.1.20 h1:VIPb/a2s17qNeQgDnkfZC35RScx+blkKF8GV68n80J4=
 github.com/creack/pty v1.1.20/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
@@ -59,11 +65,14 @@ github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/deepch/vdk v0.0.27 h1:j/SHaTiZhA47wRpaue8NRp7P9xwOOO/lunxrDJBwcao=
 github.com/deepch/vdk v0.0.27/go.mod h1:JlgGyR2ld6+xOIHa7XAxJh+stSDBAkdNvIPkUIdIywk=
-github.com/emiago/sipgo v0.22.0 h1:GaQ51m26M9QnVBVY2aDJ/mXqq/BDfZ1A+nW7XgU/4Ts=
-github.com/emiago/sipgo v0.22.0/go.mod h1:a77FgPEEjJvfYWYfP3p53u+dNhWEMb/VGVS6guvBzx0=
-github.com/frankban/quicktest v1.11.3/go.mod h1:wRf/ReqHper53s+kmmSZizM8NamnL3IM0I9ntUbOk+k=
-github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c=
+github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4=
+github.com/elgs/gostrgen v0.0.0-20220325073726-0c3e00d082f6 h1:x9TA+vnGEyqmWY+eA9HfgxNRkOQqwiEpFE9IPXSGuEA=
+github.com/elgs/gostrgen v0.0.0-20220325073726-0c3e00d082f6/go.mod h1:wruC5r2gHdr/JIUs5Rr1V45YtsAzKXZxAnn/5rPC97g=
+github.com/emiago/sipgo v1.0.0-alpha h1:w98VF4Qq3o+CcKPNe6PIouYy/mQdI66yeQGhYrwXX5Y=
+github.com/emiago/sipgo v1.0.0-alpha/go.mod h1:DuwAxBZhKMqIzQFPGZb1MVAGU6Wuxj64oTOhd5dx/FY=
+github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
+github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
 github.com/go-delve/delve v1.23.0 h1:jYgZISZ14KAO3ys8kD07kjrowrygE9F9SIwnpz9xXys=
 github.com/go-delve/delve v1.23.0/go.mod h1:S3SLuEE2mn7wipKilTvk1p9HdTMnXXElcEpiZ+VcuqU=
 github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
@@ -74,45 +83,31 @@ github.com/go-quicktest/qt v1.101.0 h1:O1K29Txy5P2OK0dGo59b7b0LR6wKfIhttaAhHUyn7
 github.com/go-quicktest/qt v1.101.0/go.mod h1:14Bz/f7NwaXPtdYEgzsx46kqSxVwTbzVZsDC26tQJow=
 github.com/go-sql-driver/mysql v1.7.0 h1:ueSltNNllEqE3qcWBTD0iQd3IpL/6U+mJxLkazJ7YPc=
 github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
-github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
 github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
 github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
-github.com/go-test/deep v1.1.0 h1:WOcxcdHcvdgThNXjw0t76K42FXTU7HpNQWHpA2HHNlg=
-github.com/go-test/deep v1.1.0/go.mod h1:5C2ZWiW0ErCdrYzpqxLbTX7MG14M9iiw8DgHncVwcsE=
 github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
 github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
 github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
 github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
 github.com/gobwas/ws v1.3.2 h1:zlnbNHxumkRvfPWgfXu8RBwyNR1x8wh9cf5PTOCqs9Q=
 github.com/gobwas/ws v1.3.2/go.mod h1:hRKAFb8wOxFROYNsT1bqfWnhX+b5MFeJM9r2ZSwg/KY=
-github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang-jwt/jwt/v5 v5.2.3 h1:kkGXqQOBSDDWRhWNXTFpqGSCMyh/PLnqUvMGJPDJDs0=
+github.com/golang-jwt/jwt/v5 v5.2.3/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
+github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
 github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/google/gopacket v1.1.19 h1:ves8RnFZPGiFnTS0uPQStjwru6uO6h+nlr9j6fL7kF8=
-github.com/google/gopacket v1.1.19/go.mod h1:iJ8V8n6KS+z2U1A8pUwu8bW5SyEMkXJB8Yo/Vo+TKTo=
+github.com/google/go-querystring v1.0.0 h1:Xkwi/a1rcvNg1PPYe5vI8GbeBY/jrVuDX5ASuANWTrk=
+github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
 github.com/google/pprof v0.0.0-20240409012703-83162a5b38cd h1:gbpYu9NMq8jhDVbvlGkMFWCjLFlqqEZjEmObmhUy6Vo=
 github.com/google/pprof v0.0.0-20240409012703-83162a5b38cd/go.mod h1:kf6iHlnVGwgKolg33glAes7Yg/8iWP8ukqeldJSO7jw=
+github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY=
@@ -121,11 +116,12 @@ github.com/grpc-ecosystem/grpc-gateway/v2 v2.19.1 h1:/c3QmbOGMGTOumP2iT/rCwB7b0Q
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.19.1/go.mod h1:5SN9VR2LTsRFsrEC6FHgRbTWrTHu6tqPeKxEQv15giM=
 github.com/hashicorp/golang-lru v1.0.2 h1:dV3g9Z/unq5DpblPpw+Oqcv4dU/1omnb4Ok8iPY6p1c=
 github.com/hashicorp/golang-lru v1.0.2/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
-github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/husanpao/ip v0.0.0-20220711082147-73160bb611a8 h1:4Jk58quTZmzJcTrLlbB5L1Q6qXu49EIjCReWxcBFWKo=
 github.com/husanpao/ip v0.0.0-20220711082147-73160bb611a8/go.mod h1:medl9/CfYoQlqAXtAARmMW5dAX2UOdwwkhaszYPk0AM=
-github.com/icholy/digest v0.1.22 h1:dRIwCjtAcXch57ei+F0HSb5hmprL873+q7PoVojdMzM=
-github.com/icholy/digest v0.1.22/go.mod h1:uLAeDdWKIWNFMH0wqbwchbTQOmJWhzSnL7zmqSPqEEc=
+github.com/ianlancetaylor/demangle v0.0.0-20240912202439-0a2b6291aafd h1:EVX1s+XNss9jkRW9K6XGJn2jL2lB1h5H804oKPsxOec=
+github.com/ianlancetaylor/demangle v0.0.0-20240912202439-0a2b6291aafd/go.mod h1:gx7rwoVhcfuVKG5uya9Hs3Sxj7EIvldVofAWIUtGouw=
+github.com/icholy/digest v1.1.0 h1:HfGg9Irj7i+IX1o1QAmPfIBNu/Q5A5Tu3n/MED9k9H4=
+github.com/icholy/digest v1.1.0/go.mod h1:QNrsSGQ5v7v9cReDI0+eyjsXGUoRSUZQHeQ5C4XLa0Y=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
@@ -134,16 +130,25 @@ github.com/jackc/pgx/v5 v5.5.5 h1:amBjrZVmksIdNjxGW/IiIMzxMKZFelXbUoPNb+8sjQw=
 github.com/jackc/pgx/v5 v5.5.5/go.mod h1:ez9gk+OAat140fv9ErkZDYFWmXLfV+++K0uAOiwgm1A=
 github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
 github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/jinzhu/copier v0.4.0 h1:w3ciUoD19shMCRargcpm0cm91ytaBhDvuRpz1ODO/U8=
+github.com/jinzhu/copier v0.4.0/go.mod h1:DfbEm0FYsaqBcKcFuvmOZb218JkPGtvSHsKg8S8hyyg=
 github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
 github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
+github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
+github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
+github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8=
+github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
 github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
 github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
-github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
-github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+github.com/juju/errors v1.0.0 h1:yiq7kjCLll1BiaRuNY53MGI0+EQ3rF6GB+wvboZDefM=
+github.com/juju/errors v1.0.0/go.mod h1:B5x9thDqx0wIMH3+aLIMP9HjItInYWObRovoCFM5Qe8=
+github.com/kerberos-io/onvif v1.0.0 h1:pLJrK6skPkK+5Bj4XfqHUkQ2I+p5pwELnp+kQTJWXiQ=
+github.com/kerberos-io/onvif v1.0.0/go.mod h1:P1kUcCfeotJSlL1jwGseH6NSnCwWiuJLl3gAzafnLbA=
+github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
+github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
@@ -153,6 +158,10 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/langhuihui/gomem v0.0.0-20251001011839-023923cf7683 h1:lITBgMb71ad6OUU9gycsheCw9PpMbXy3/QA8T0V0dVM=
+github.com/langhuihui/gomem v0.0.0-20251001011839-023923cf7683/go.mod h1:BTPq1+4YUP4i7w8VHzs5AUIdn3T5gXjIUXbxgHW9TIQ=
+github.com/langhuihui/gotask v1.0.2 h1:vcQ/9yD0+x2DkSrDBkYpufOyJxXs7i5fd7wUD8gvLLs=
+github.com/langhuihui/gotask v1.0.2/go.mod h1:2zNqwV8M1pHoO0b5JC/A37oYpdtXrfL10Qof9AvR5IE=
 github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80 h1:6Yzfa6GP0rIo/kULo2bwGEkFvCePZ3qHDDTC3/J9Swo=
 github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80/go.mod h1:imJHygn/1yfhB7XSJJKlFZKl/J+dCPAknuiaGOshXAs=
 github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 h1:6E+4a0GO5zZEnZ81pIr0yLvtUWk2if982qA3F3QD6H4=
@@ -161,41 +170,34 @@ github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0
 github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
 github.com/marcboeker/go-duckdb v1.0.5 h1:zIfyrCAJfY9FmXWOZ6jE3DkmWpwK4rlY12zqf9LD2mU=
 github.com/marcboeker/go-duckdb v1.0.5/go.mod h1:wm91jO2GNKa6iO9NTcjXIRsW+/ykPoJbQcHSXhdAl28=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mark3labs/mcp-go v0.27.0 h1:iok9kU4DUIU2/XVLgFS2Q9biIDqstC0jY4EQTK2Erzc=
+github.com/mark3labs/mcp-go v0.27.0/go.mod h1:rXqOudj/djTORU/ThxYx8fqEVj/5pvTuuebQ2RC7uk4=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM=
 github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/mcuadros/go-defaults v1.2.0 h1:FODb8WSf0uGaY8elWJAkoLL0Ri6AlZ1bFlenk56oZtc=
 github.com/mcuadros/go-defaults v1.2.0/go.mod h1:WEZtHEVIGYVDqkKSWBdWKUVdRyKlMfulPaGDWIVeCWY=
-github.com/miekg/dns v1.1.35/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
+github.com/mitchellh/mapstructure v1.4.3/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
 github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
 github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/mozillazg/go-httpheader v0.2.1 h1:geV7TrjbL8KXSyvghnFm+NyTux/hxwueTSrwhe88TQQ=
+github.com/mozillazg/go-httpheader v0.2.1/go.mod h1:jJ8xECTlalr6ValeXYdOF8fFUISeBAdw6E61aqQma60=
+github.com/mozillazg/go-pinyin v0.20.0 h1:BtR3DsxpApHfKReaPO1fCqF4pThRwH9uwvXzm+GnMFQ=
+github.com/mozillazg/go-pinyin v0.20.0/go.mod h1:iR4EnMMRXkfpFVV5FMi4FNB6wGq9NV6uDWbUuPhP4Yc=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
-github.com/ncruces/go-sqlite3 v0.18.1 h1:iN8IMZV5EMxpH88NUac9vId23eTKNFUhP7jgY0EBbNc=
-github.com/ncruces/go-sqlite3 v0.18.1/go.mod h1:eEOyZnW1dGTJ+zDpMuzfYamEUBtdFz5zeYhqLBtHxvM=
-github.com/ncruces/go-sqlite3/gormlite v0.18.0 h1:KqP9a9wlX/Ba+yG+aeVX4pnNBNdaSO6xHdNDWzPxPnk=
-github.com/ncruces/go-sqlite3/gormlite v0.18.0/go.mod h1:RXeT1hknrz3A0tBDL6IfluDHuNkHdJeImn5TBMQg9zc=
+github.com/ncruces/go-sqlite3 v0.27.1 h1:suqlM7xhSyDVMV9RgX99MCPqt9mB6YOCzHZuiI36K34=
+github.com/ncruces/go-sqlite3 v0.27.1/go.mod h1:gpF5s+92aw2MbDmZK0ZOnCdFlpe11BH20CTspVqri0c=
+github.com/ncruces/go-sqlite3/gormlite v0.24.0 h1:81sHeq3CCdhjoqAB650n5wEdRlLO9VBvosArskcN3+c=
+github.com/ncruces/go-sqlite3/gormlite v0.24.0/go.mod h1:vXfVWdBfg7qOgqQqHpzUWl9LLswD0h+8mK4oouaV2oc=
 github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M=
 github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
 github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
-github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
-github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
-github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
-github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0=
-github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
 github.com/onsi/ginkgo/v2 v2.9.5 h1:+6Hr4uxzP4XIUyAkg61dWBw8lb/gc4/X5luuxN/EC+Q=
 github.com/onsi/ginkgo/v2 v2.9.5/go.mod h1:tvAoo1QUJwNEU2ITftXTpR7R1RbCzoZUOs3RonqW57k=
-github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
-github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
-github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
 github.com/onsi/gomega v1.27.6 h1:ENqfyGeS5AX/rlXDd/ETokDz93u0YufY1Pgxuy/PvWE=
 github.com/onsi/gomega v1.27.6/go.mod h1:PIQNjfQwkP3aQAH7lf7j87O/5FiNr+ZR8+ipb+qQlhg=
 github.com/orcaman/writerseeker v0.0.0-20200621085525-1d3f536ff85e h1:s2RNOM/IGdY0Y6qfTeUKhDawdHDpK9RGBdx80qN4Ttw=
@@ -204,60 +206,38 @@ github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde h1:x0TT0RDC7UhA
 github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde/go.mod h1:nZgzbfBr3hhjoZnS66nKrHmduYNpc34ny7RK4z5/HM0=
 github.com/phsym/console-slog v0.3.1 h1:Fuzcrjr40xTc004S9Kni8XfNsk+qrptQmyR+wZw9/7A=
 github.com/phsym/console-slog v0.3.1/go.mod h1:oJskjp/X6e6c0mGpfP8ELkfKUsrkDifYRAqJQgmdDS0=
-github.com/pion/datachannel v1.5.5/go.mod h1:iMz+lECmfdCMqFRhXhcA/219B0SQlbpoR2V118yimL0=
-github.com/pion/datachannel v1.5.6 h1:1IxKJntfSlYkpUj8LlYRSWpYiTTC02nUrOE8T3DqGeg=
-github.com/pion/datachannel v1.5.6/go.mod h1:1eKT6Q85pRnr2mHiWHxJwO50SfZRtWHTsNIVb/NfGW4=
-github.com/pion/dtls/v2 v2.2.7/go.mod h1:8WiMkebSHFD0T+dIU+UeBaoV7kDhOW5oDCzZ7WZ/F9s=
-github.com/pion/dtls/v2 v2.2.11 h1:9U/dpCYl1ySttROPWJgqWKEylUdT0fXp/xst6JwY5Ks=
-github.com/pion/dtls/v2 v2.2.11/go.mod h1:d9SYc9fch0CqK90mRk1dC7AkzzpwJj6u2GU3u+9pqFE=
-github.com/pion/ice/v2 v2.3.9 h1:7yZpHf3PhPxJGT4JkMj1Y8Rl5cQ6fB709iz99aeMd/U=
-github.com/pion/ice/v2 v2.3.9/go.mod h1:lT3kv5uUIlHfXHU/ZRD7uKD/ufM202+eTa3C/umgGf4=
-github.com/pion/interceptor v0.1.17/go.mod h1:SY8kpmfVBvrbUzvj2bsXz7OJt5JvmVNZ+4Kjq7FcwrI=
-github.com/pion/interceptor v0.1.29 h1:39fsnlP1U8gw2JzOFWdfCU82vHvhW9o0rZnZF56wF+M=
-github.com/pion/interceptor v0.1.29/go.mod h1:ri+LGNjRUc5xUNtDEPzfdkmSqISixVTBF/z/Zms/6T4=
-github.com/pion/logging v0.2.2 h1:M9+AIj/+pxNsDfAT64+MAVgJO0rsyLnoJKCqf//DoeY=
-github.com/pion/logging v0.2.2/go.mod h1:k0/tDVsRCX2Mb2ZEmTqNa7CWsQPc+YYCB7Q+5pahoms=
-github.com/pion/mdns v0.0.7/go.mod h1:4iP2UbeFhLI/vWju/bw6ZfwjJzk0z8DNValjGxR/dD8=
-github.com/pion/mdns v0.0.12 h1:CiMYlY+O0azojWDmxdNr7ADGrnZ+V6Ilfner+6mSVK8=
-github.com/pion/mdns v0.0.12/go.mod h1:VExJjv8to/6Wqm1FXK+Ii/Z9tsVk/F5sD/N70cnYFbk=
+github.com/pion/datachannel v1.5.10 h1:ly0Q26K1i6ZkGf42W7D4hQYR90pZwzFOjTq5AuCKk4o=
+github.com/pion/datachannel v1.5.10/go.mod h1:p/jJfC9arb29W7WrxyKbepTU20CFgyx5oLo8Rs4Py/M=
+github.com/pion/dtls/v3 v3.0.7 h1:bItXtTYYhZwkPFk4t1n3Kkf5TDrfj6+4wG+CZR8uI9Q=
+github.com/pion/dtls/v3 v3.0.7/go.mod h1:uDlH5VPrgOQIw59irKYkMudSFprY9IEFCqz/eTz16f8=
+github.com/pion/ice/v4 v4.0.10 h1:P59w1iauC/wPk9PdY8Vjl4fOFL5B+USq1+xbDcN6gT4=
+github.com/pion/ice/v4 v4.0.10/go.mod h1:y3M18aPhIxLlcO/4dn9X8LzLLSma84cx6emMSu14FGw=
+github.com/pion/interceptor v0.1.40 h1:e0BjnPcGpr2CFQgKhrQisBU7V3GXK6wrfYrGYaU6Jq4=
+github.com/pion/interceptor v0.1.40/go.mod h1:Z6kqH7M/FYirg3frjGJ21VLSRJGBXB/KqaTIrdqnOic=
+github.com/pion/logging v0.2.4 h1:tTew+7cmQ+Mc1pTBLKH2puKsOvhm32dROumOZ655zB8=
+github.com/pion/logging v0.2.4/go.mod h1:DffhXTKYdNZU+KtJ5pyQDjvOAh/GsNSyv1lbkFbe3so=
+github.com/pion/mdns/v2 v2.0.7 h1:c9kM8ewCgjslaAmicYMFQIde2H9/lrZpjBkN8VwoVtM=
+github.com/pion/mdns/v2 v2.0.7/go.mod h1:vAdSYNAT0Jy3Ru0zl2YiW3Rm/fJCwIeM0nToenfOJKA=
 github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA=
 github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
-github.com/pion/rtcp v1.2.10/go.mod h1:ztfEwXZNLGyF1oQDttz/ZKIBaeeg/oWbRYqzBM9TL1I=
-github.com/pion/rtcp v1.2.14 h1:KCkGV3vJ+4DAJmvP0vaQShsb0xkRfWkO540Gy102KyE=
-github.com/pion/rtcp v1.2.14/go.mod h1:sn6qjxvnwyAkkPzPULIbVqSKI5Dv54Rv7VG0kNxh9L4=
-github.com/pion/rtp v1.7.13/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko=
-github.com/pion/rtp v1.8.6 h1:MTmn/b0aWWsAzux2AmP8WGllusBVw4NPYPVFFd7jUPw=
-github.com/pion/rtp v1.8.6/go.mod h1:pBGHaFt/yW7bf1jjWAoUjpSNoDnw98KTMg+jWWvziqU=
-github.com/pion/sctp v1.8.5/go.mod h1:SUFFfDpViyKejTAdwD1d/HQsCu+V/40cCs2nZIvC3s0=
-github.com/pion/sctp v1.8.7/go.mod h1:g1Ul+ARqZq5JEmoFy87Q/4CePtKnTJ1QCL9dBBdN6AU=
-github.com/pion/sctp v1.8.13/go.mod h1:YKSgO/bO/6aOMP9LCie1DuD7m+GamiK2yIiPM6vH+GA=
-github.com/pion/sctp v1.8.16 h1:PKrMs+o9EMLRvFfXq59WFsC+V8mN1wnKzqrv+3D/gYY=
-github.com/pion/sctp v1.8.16/go.mod h1:P6PbDVA++OJMrVNg2AL3XtYHV4uD6dvfyOovCgMs0PE=
-github.com/pion/sdp/v3 v3.0.6/go.mod h1:iiFWFpQO8Fy3S5ldclBkpXqmWy02ns78NOKoLLL0YQw=
-github.com/pion/sdp/v3 v3.0.9 h1:pX++dCHoHUwq43kuwf3PyJfHlwIj4hXA7Vrifiq0IJY=
-github.com/pion/sdp/v3 v3.0.9/go.mod h1:B5xmvENq5IXJimIO4zfp6LAe1fD9N+kFv+V/1lOdz8M=
-github.com/pion/srtp/v2 v2.0.15 h1:+tqRtXGsGwHC0G0IUIAzRmdkHvriF79IHVfZGfHrQoA=
-github.com/pion/srtp/v2 v2.0.15/go.mod h1:b/pQOlDrbB0HEH5EUAQXzSYxikFbNcNuKmF8tM0hCtw=
-github.com/pion/stun v0.6.1 h1:8lp6YejULeHBF8NmV8e2787BogQhduZugh5PdhDyyN4=
-github.com/pion/stun v0.6.1/go.mod h1:/hO7APkX4hZKu/D0f2lHzNyvdkTGtIy3NDmLR7kSz/8=
-github.com/pion/transport v0.14.1 h1:XSM6olwW+o8J4SCmOBb/BpwZypkHeyM0PGFCxNQBr40=
-github.com/pion/transport v0.14.1/go.mod h1:4tGmbk00NeYA3rUa9+n+dzCCoKkcy3YlYb99Jn2fNnI=
-github.com/pion/transport/v2 v2.0.0/go.mod h1:HS2MEBJTwD+1ZI2eSXSvHJx/HnzQqRy2/LXxt6eVMHc=
-github.com/pion/transport/v2 v2.1.0/go.mod h1:AdSw4YBZVDkZm8fpoz+fclXyQwANWmZAlDuQdctTThQ=
-github.com/pion/transport/v2 v2.2.0/go.mod h1:AdSw4YBZVDkZm8fpoz+fclXyQwANWmZAlDuQdctTThQ=
-github.com/pion/transport/v2 v2.2.1/go.mod h1:cXXWavvCnFF6McHTft3DWS9iic2Mftcz1Aq29pGcU5g=
-github.com/pion/transport/v2 v2.2.4/go.mod h1:q2U/tf9FEfnSBGSW6w5Qp5PFWRLRj3NjLhCCgpRK4p0=
-github.com/pion/transport/v2 v2.2.5 h1:iyi25i/21gQck4hfRhomF6SktmUQjRsRW4WJdhfc3Kc=
-github.com/pion/transport/v2 v2.2.5/go.mod h1:q2U/tf9FEfnSBGSW6w5Qp5PFWRLRj3NjLhCCgpRK4p0=
-github.com/pion/transport/v3 v3.0.1/go.mod h1:UY7kiITrlMv7/IKgd5eTUcaahZx5oUN3l9SzK5f5xE0=
-github.com/pion/transport/v3 v3.0.2 h1:r+40RJR25S9w3jbA6/5uEPTzcdn7ncyU44RWCbHkLg4=
-github.com/pion/transport/v3 v3.0.2/go.mod h1:nIToODoOlb5If2jF9y2Igfx3PFYWfuXi37m0IlWa/D0=
-github.com/pion/turn/v2 v2.1.2 h1:wj0cAoGKltaZ790XEGW9HwoUewqjliwmhtxCuB2ApyM=
-github.com/pion/turn/v2 v2.1.2/go.mod h1:1kjnPkBcex3dhCU2Am+AAmxDcGhLX3WnMfmkNpvSTQU=
-github.com/pion/webrtc/v3 v3.2.12 h1:pVqz5NdtTqyhKIhMcXR8bPp709kCf9blyAhDjoVRLvA=
-github.com/pion/webrtc/v3 v3.2.12/go.mod h1:/Oz6K95CGWaN+3No+Z0NYvgOPOr3aY8UyTlMm/dec3A=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pion/rtcp v1.2.15 h1:LZQi2JbdipLOj4eBjK4wlVoQWfrZbh3Q6eHtWtJBZBo=
+github.com/pion/rtcp v1.2.15/go.mod h1:jlGuAjHMEXwMUHK78RgX0UmEJFV4zUKOFHR7OP+D3D0=
+github.com/pion/rtp v1.8.21 h1:3yrOwmZFyUpcIosNcWRpQaU+UXIJ6yxLuJ8Bx0mw37Y=
+github.com/pion/rtp v1.8.21/go.mod h1:bAu2UFKScgzyFqvUKmbvzSdPr+NGbZtv6UB2hesqXBk=
+github.com/pion/sctp v1.8.39 h1:PJma40vRHa3UTO3C4MyeJDQ+KIobVYRZQZ0Nt7SjQnE=
+github.com/pion/sctp v1.8.39/go.mod h1:cNiLdchXra8fHQwmIoqw0MbLLMs+f7uQ+dGMG2gWebE=
+github.com/pion/sdp/v3 v3.0.15 h1:F0I1zds+K/+37ZrzdADmx2Q44OFDOPRLhPnNTaUX9hk=
+github.com/pion/sdp/v3 v3.0.15/go.mod h1:88GMahN5xnScv1hIMTqLdu/cOcUkj6a9ytbncwMCq2E=
+github.com/pion/srtp/v3 v3.0.7 h1:QUElw0A/FUg3MP8/KNMZB3i0m8F9XeMnTum86F7S4bs=
+github.com/pion/srtp/v3 v3.0.7/go.mod h1:qvnHeqbhT7kDdB+OGB05KA/P067G3mm7XBfLaLiaNF0=
+github.com/pion/stun/v3 v3.0.0 h1:4h1gwhWLWuZWOJIJR9s2ferRO+W3zA/b6ijOI6mKzUw=
+github.com/pion/stun/v3 v3.0.0/go.mod h1:HvCN8txt8mwi4FBvS3EmDghW6aQJ24T+y+1TKjB5jyU=
+github.com/pion/transport/v3 v3.0.7 h1:iRbMH05BzSNwhILHoBoAPxoB9xQgOaJk+591KC9P1o0=
+github.com/pion/transport/v3 v3.0.7/go.mod h1:YleKiTZ4vqNxVwh77Z0zytYi7rXHl7j6uPLGhhz9rwo=
+github.com/pion/turn/v4 v4.1.1 h1:9UnY2HB99tpDyz3cVVZguSxcqkJ1DsTSZ+8TGruh4fc=
+github.com/pion/turn/v4 v4.1.1/go.mod h1:2123tHk1O++vmjI5VSD0awT50NywDAq5A2NNNU4Jjs8=
+github.com/pion/webrtc/v4 v4.1.4 h1:/gK1ACGHXQmtyVVbJFQDxNoODg4eSRiFLB7t9r9pg8M=
+github.com/pion/webrtc/v4 v4.1.4/go.mod h1:Oab9npu1iZtQRMic3K3toYq5zFPvToe/QBw7dMI2ok4=
 github.com/pkg/profile v1.4.0/go.mod h1:NWz/XGvpEW1FyYQ7fCx4dqYBLlfTcE+A9FLAkNKqjFE=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
@@ -274,13 +254,13 @@ github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0leargg
 github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
 github.com/quangngotan95/go-m3u8 v0.1.0 h1:8oseBjJn5IKHQKdRZwSNskkua3NLrRtlvXXtoVgBzMk=
 github.com/quangngotan95/go-m3u8 v0.1.0/go.mod h1:smzfWHlYpBATVNu1GapKLYiCtEo5JxridIgvvudZ+Wc=
-github.com/quic-go/quic-go v0.43.1 h1:fLiMNfQVe9q2JvSsiXo4fXOEguXHGGl9+6gLp4RPeZQ=
-github.com/quic-go/quic-go v0.43.1/go.mod h1:132kz4kL3F9vxhW3CtQJLDVwcFe5wdWeJXXijhsO57M=
+github.com/quic-go/qpack v0.5.1 h1:giqksBPnT/HDtZ6VhtFKgoLOWmlyo9Ei6u9PqzIMbhI=
+github.com/quic-go/qpack v0.5.1/go.mod h1:+PC4XFrEskIVkcLzpEkbLqq1uCoxPhQuvK5rH1ZgaEg=
+github.com/quic-go/quic-go v0.50.1 h1:unsgjFIUqW8a2oopkY7YNONpV1gYND6Nt9hnt1PN94Q=
+github.com/quic-go/quic-go v0.50.1/go.mod h1:Vim6OmUvlYdwBhXP9ZVrtGmCMWa3wEqhq3NgYrI8b4E=
 github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
 github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
-github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
-github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
-github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
+github.com/rs/dnscache v0.0.0-20230804202142-fc85eb664529/go.mod h1:qe5TWALJ8/a1Lqznoc5BDHpYX/8HU60Hm2AwRmqzxqA=
 github.com/samber/lo v1.44.0 h1:5il56KxRE+GHsm1IR+sZ/6J42NODigFiqCWpSc2dybA=
 github.com/samber/lo v1.44.0/go.mod h1:RmDH9Ct32Qy3gduHQuKJ3gW1fMHAnE/fAzQuf6He5cU=
 github.com/samber/slog-common v0.17.1 h1:jTqqLBgoJshpoxlPSGiypyOanjH6tY+i9bwyYmIbjhI=
@@ -289,9 +269,6 @@ github.com/samber/slog-formatter v1.0.0 h1:ULxHV+jNqi6aFP8xtzGHl2ejFRMl2+jI2UhCp
 github.com/samber/slog-formatter v1.0.0/go.mod h1:c7pRfwhCfZQNzJz+XirmTveElxXln7M0Y8Pq781uxlo=
 github.com/samber/slog-multi v1.0.0 h1:snvP/P5GLQ8TQh5WSqdRaxDANW8AAA3egwEoytLsqvc=
 github.com/samber/slog-multi v1.0.0/go.mod h1:uLAvHpGqbYgX4FSL0p1ZwoLuveIAJvBECtE07XmYvFo=
-github.com/satori/go.uuid v1.2.1-0.20181028125025-b2ce2384e17b h1:gQZ0qzfKHQIybLANtM3mBXNUtOfsCFXeTsnBqCsx1KM=
-github.com/satori/go.uuid v1.2.1-0.20181028125025-b2ce2384e17b/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
-github.com/sclevine/agouti v3.0.0+incompatible/go.mod h1:b4WX9W9L1sfQKXeJf1mUTLZKJ48R1S7H23Ji7oFO5Bw=
 github.com/shirou/gopsutil/v4 v4.24.8 h1:pVQjIenQkIhqO81mwTaXjTzOMT7d3TZkf43PlVFHENI=
 github.com/shirou/gopsutil/v4 v4.24.8/go.mod h1:wE0OrJtj4dG+hYkxqDH3QiBICdKSf04/npcvLLc/oRg=
 github.com/shoenig/go-m1cpu v0.1.6 h1:nxdKQNcEB6vzgA2E2bvzKIYRuNj7XNJ4S/aRSwKzFtM=
@@ -300,33 +277,31 @@ github.com/shoenig/test v0.6.4 h1:kVTaSd7WLz5WZ2IaoM0RSzRsUD+m8wRR+5qvntpn4LU=
 github.com/shoenig/test v0.6.4/go.mod h1:byHiCGXqrVaflBLAMq/srcZIHynQPQgeyvkvXnjqq0k=
 github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
 github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
-github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/cast v1.7.1 h1:cuNEagBQEHWN1FnbGEjCXL2szYEXqfJPbP2HNUaca9Y=
+github.com/spf13/cast v1.7.1/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/sunfish-shogi/bufseekio v0.0.0-20210207115823-a4185644b365/go.mod h1:dEzdXgvImkQ3WLI+0KQpmEx8T/C/ma9KeS3AfmU899I=
-github.com/tetratelabs/wazero v1.8.0 h1:iEKu0d4c2Pd+QSRieYbnQC9yiFlMS9D+Jr0LsRmcF4g=
-github.com/tetratelabs/wazero v1.8.0/go.mod h1:yAI0XTsMBhREkM/YDAK/zNou3GoiAce1P6+rp/wQhjs=
+github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common v1.0.563/go.mod h1:7sCQWVkxcsR38nffDW057DRGk8mUjK1Ing/EFOK8s8Y=
+github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/kms v1.0.563/go.mod h1:uom4Nvi9W+Qkom0exYiJ9VWJjXwyxtPYTkKkaLMlfE0=
+github.com/tencentyun/cos-go-sdk-v5 v0.7.69 h1:9O5/Nt1eXf/Y6HNP4yUC0OdbKbSv5MDZRNGZBA/XXug=
+github.com/tencentyun/cos-go-sdk-v5 v0.7.69/go.mod h1:STbTNaNKq03u+gscPEGOahKzLcGSYOj6Dzc5zNay7Pg=
+github.com/tencentyun/qcloud-cos-sts-sdk v0.0.0-20250515025012-e0eec8a5d123/go.mod h1:b18KQa4IxHbxeseW1GcZox53d7J0z39VNONTxvvlkXw=
+github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
+github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
 github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU=
 github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI=
 github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk=
 github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasthttp v1.61.0 h1:VV08V0AfoRaFurP1EWKvQQdPTZHiUzaVoulX1aBDgzU=
+github.com/valyala/fasthttp v1.61.0/go.mod h1:wRIV/4cMwUPWnRcDno9hGnYZGh78QzODFfo1LTUhBog=
 github.com/valyala/fastjson v1.6.4 h1:uAUNq9Z6ymTgGhcm0UynUAB6tlbakBrz6CQFax3BXVQ=
 github.com/valyala/fastjson v1.6.4/go.mod h1:CLCAqky6SMuOcxStkYQvblddUtoRxhYMGLrsQns1aXY=
 github.com/valyala/fastrand v1.1.0 h1:f+5HkLW4rsgzdNoleUOB69hyT9IlD2ZQh9GyDMfb5G8=
@@ -337,185 +312,74 @@ github.com/valyala/histogram v1.2.0 h1:wyYGAZZt3CpwUiIb9AU/Zbllg1llXyrtApRS815OL
 github.com/valyala/histogram v1.2.0/go.mod h1:Hb4kBwb4UxsaNbbbh+RRz8ZR6pdodR57tzWUS3BUzXY=
 github.com/valyala/quicktemplate v1.8.0 h1:zU0tjbIqTRgKQzFY1L42zq0qR3eh4WoQQdIdqCysW5k=
 github.com/valyala/quicktemplate v1.8.0/go.mod h1:qIqW8/igXt8fdrUln5kOSb+KWMaJ4Y8QUsfd1k6L2jM=
-github.com/vishvananda/netlink v1.1.0 h1:1iyaYNBLmP6L0220aDnYQpo1QEV4t4hJ+xEEhhJH8j0=
-github.com/vishvananda/netlink v1.1.0/go.mod h1:cTgwzPIzzgDAYoQrMm0EdrjRUBkTqKYppBueQtXaqoE=
-github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df h1:OviZH7qLw/7ZovXvuNyL3XQl8UFofeikI1NW1Gypu7k=
-github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df/go.mod h1:JP3t17pCcGlemwknint6hfoeCVQrEMVwxRLRjXpq+BU=
+github.com/wlynxg/anet v0.0.5 h1:J3VJGi1gvo0JwZ/P1/Yc/8p63SoW98B5dHkYDmpgvvU=
+github.com/wlynxg/anet v0.0.5/go.mod h1:eay5PRQr7fIVAMbTbchTnO9gG65Hg/uYGdc7mguHxoA=
+github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
+github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
 github.com/yapingcat/gomedia v0.0.0-20240601043430-920523f8e5c7 h1:e9n2WNcfvs20aLgpDhKoaJgrU/EeAvuNnWLBm31Q5Fw=
 github.com/yapingcat/gomedia v0.0.0-20240601043430-920523f8e5c7/go.mod h1:WSZ59bidJOO40JSJmLqlkBJrjZCtjbKKkygEMfzY/kc=
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+github.com/yosida95/uritemplate/v3 v3.0.2 h1:Ed3Oyj9yrmi9087+NczuL5BwkIc4wvTb5zIM+UJPGz4=
+github.com/yosida95/uritemplate/v3 v3.0.2/go.mod h1:ILOh0sOhIJR3+L/8afwt/kE++YT040gmv5BQTMR2HP4=
 github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
 github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
-go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU=
-go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc=
-golang.org/x/arch v0.6.0 h1:S0JTfE48HbRj80+4tbvZDYsJ3tGv6BUU3XxyZ7CirAc=
-golang.org/x/arch v0.6.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE=
-golang.org/x/crypto v0.10.0/go.mod h1:o4eNf7Ede1fv+hwOwZsTHl9EsPFO6q6ZvYR8vYfY45I=
-golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
-golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
-golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
-golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
-golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw=
-golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54=
+go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU=
+go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM=
+golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc=
+golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/crypto v0.40.0 h1:r4x+VvoG5Fm+eJcxMaY8CQM7Lb0l1lsmjGBQ6s8BfKM=
+golang.org/x/crypto v0.40.0/go.mod h1:Qr1vMER5WyS2dfPHAlsOj01wgLbsyWtFn/aY+5+ZdxY=
 golang.org/x/exp v0.0.0-20240716175740-e3f259677ff7 h1:wDLEX9a7YQoKdKNQt88rtydkqDxeGaBUTnIYc3iG/mA=
 golang.org/x/exp v0.0.0-20240716175740-e3f259677ff7/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
-golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/mod v0.19.0 h1:fEdghXQSo20giMthA7cd28ZC+jts4amQ3YMXiP5oMQ8=
-golang.org/x/mod v0.19.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
-golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco=
-golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws=
-golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
-golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
-golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
-golang.org/x/net v0.11.0/go.mod h1:2L/ixqYpgIVXmeoSA/4Lu7BzTG4KIyPIryS4IsOd1oQ=
-golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI=
-golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
-golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
-golang.org/x/net v0.22.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
-golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
-golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/image v0.22.0 h1:UtK5yLUzilVrkjMAZAZ34DXGpASN8i8pj8g+O+yd10g=
+golang.org/x/image v0.22.0/go.mod h1:9hPFhljd4zZ1GNSIZJ49sqbp45GKK9t6w+iXvGqZUz4=
+golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w=
+golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
+golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
+golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
-golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190606203320-7fc4e5ec1444/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
+golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210324051608-47abb6519492/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
-golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/sys v0.34.0 h1:H5Y5sJ2L2JRdyv7ROF1he/lPdvFsd0mJHFw2ThKHxLA=
+golang.org/x/sys v0.34.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ=
-golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
-golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
-golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
-golang.org/x/term v0.9.0/go.mod h1:M6DEAAIenWoTxdKrOltXcmDY3rSplQUkrvaDU5FcQyo=
-golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU=
-golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=
-golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
-golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/text v0.10.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
-golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc=
-golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+golang.org/x/text v0.27.0 h1:4fGWRpyh641NLlecmyl4LOe6yDdfaYNrGb2zdfo4JV4=
+golang.org/x/text v0.27.0/go.mod h1:1D28KMCvyooCX9hBiosv5Tz/+YLxj0j7XhWjpSUF7CU=
 golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
 golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190624222133-a101b041ded4/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
-golang.org/x/tools v0.23.0 h1:SGsXPZ+2l4JsgaCKkx+FQ9YZ5XEtA1GZYuoDjenLjvg=
-golang.org/x/tools v0.23.0/go.mod h1:pnu6ufv6vQkll6szChhK3C3L/ruaIv5eBeztNG8wtsI=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/tools v0.34.0 h1:qIpSLOxeCYGg9TrcJokLBG4KFA6d795g0xkBkiESGlo=
+golang.org/x/tools v0.34.0/go.mod h1:pAP9OwEaY1CAW3HOmg3hLZC5Z0CCmzjAF2UQMSqNARg=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/genproto/googleapis/api v0.0.0-20240711142825-46eb208f015d h1:kHjw/5UfflP/L5EbledDrcG4C2597RtymmGRZvHiCuY=
 google.golang.org/genproto/googleapis/api v0.0.0-20240711142825-46eb208f015d/go.mod h1:mw8MG/Qz5wfgYr6VqVCiZcHe/GJEfI+oGGDCohaVgB0=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20240711142825-46eb208f015d h1:JU0iKnSg02Gmb5ZdV8nYsKEKsP6o/FGVWTrw4i1DA9A=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20240711142825-46eb208f015d/go.mod h1:Ue6ibwXGpU+dqIcODieyLOcgj7z8+IcskoNIgZxtrFY=
 google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc=
 google.golang.org/grpc v1.65.0/go.mod h1:WgYC2ypjlB0EiQi6wdKixMqukr6lBc0Vo+oOgjrM5ZQ=
-google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
-google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
-google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
-google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
-google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
 google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
-gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/src-d/go-billy.v4 v4.3.2 h1:0SQA1pRztfTFx2miS8sA97XvooFeNOmvUenF4o0EcVg=
 gopkg.in/src-d/go-billy.v4 v4.3.2/go.mod h1:nDjArDMp+XMs1aFAESLRjfGSgfvoYN0hDfzEk0GjC98=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
@@ -526,8 +390,7 @@ 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=
-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=
+gorm.io/gorm v1.30.0 h1:qbT5aPv1UH8gI99OsRlvDToLxW5zR7FzS9acZDOZcgs=
+gorm.io/gorm v1.30.0/go.mod h1:8Z33v652h4//uMA76KjeDH8mJXPm1QNCYrMeatR0DOE=
+gotest.tools/v3 v3.5.1 h1:EENdUnS3pdur5nybKYIh2Vfgc8IUNBjxDPSjtiJcOzU=
+gotest.tools/v3 v3.5.1/go.mod h1:isy3WKz7GK6uNw/sbHzfKBLvlvXwUyV06n6brMxxopU=

goreleaser.yml

@@ -0,0 +1,26 @@
+project_name: m7s
+archives:
+  -
+    files:
+      - favicon.ico
+builds:
+  - id: "all"
+    main: ./example/default/main.go
+    env:
+      - CGO_ENABLED=0
+    tags:
+      - sqlite
+      - mysql
+      - postgres
+    ldflags:
+      - -s -w -X m7s.live/v5.Version={{.Tag}}    
+    goos:
+      - linux
+      - windows
+      - darwin
+    goarch:
+      - arm64
+      - amd64
+    hooks:
+      pre:
+        - go mod tidy

pb/auth.pb.go

@@ -0,0 +1,539 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.36.10
+// 	protoc        v6.31.1
+// source: auth.proto
+
+package pb
+
+import (
+	_ "google.golang.org/genproto/googleapis/api/annotations"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+	unsafe "unsafe"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type LoginRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Username      string                 `protobuf:"bytes,1,opt,name=username,proto3" json:"username,omitempty"`
+	Password      string                 `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *LoginRequest) Reset() {
+	*x = LoginRequest{}
+	mi := &file_auth_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *LoginRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*LoginRequest) ProtoMessage() {}
+
+func (x *LoginRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_auth_proto_msgTypes[0]
+	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 LoginRequest.ProtoReflect.Descriptor instead.
+func (*LoginRequest) Descriptor() ([]byte, []int) {
+	return file_auth_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *LoginRequest) GetUsername() string {
+	if x != nil {
+		return x.Username
+	}
+	return ""
+}
+
+func (x *LoginRequest) GetPassword() string {
+	if x != nil {
+		return x.Password
+	}
+	return ""
+}
+
+type LoginSuccess struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Token         string                 `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
+	UserInfo      *UserInfo              `protobuf:"bytes,2,opt,name=userInfo,proto3" json:"userInfo,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *LoginSuccess) Reset() {
+	*x = LoginSuccess{}
+	mi := &file_auth_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *LoginSuccess) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*LoginSuccess) ProtoMessage() {}
+
+func (x *LoginSuccess) ProtoReflect() protoreflect.Message {
+	mi := &file_auth_proto_msgTypes[1]
+	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 LoginSuccess.ProtoReflect.Descriptor instead.
+func (*LoginSuccess) Descriptor() ([]byte, []int) {
+	return file_auth_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *LoginSuccess) GetToken() string {
+	if x != nil {
+		return x.Token
+	}
+	return ""
+}
+
+func (x *LoginSuccess) GetUserInfo() *UserInfo {
+	if x != nil {
+		return x.UserInfo
+	}
+	return nil
+}
+
+type LoginResponse 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"`
+	Data          *LoginSuccess          `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *LoginResponse) Reset() {
+	*x = LoginResponse{}
+	mi := &file_auth_proto_msgTypes[2]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *LoginResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*LoginResponse) ProtoMessage() {}
+
+func (x *LoginResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_auth_proto_msgTypes[2]
+	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 LoginResponse.ProtoReflect.Descriptor instead.
+func (*LoginResponse) Descriptor() ([]byte, []int) {
+	return file_auth_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *LoginResponse) GetCode() int32 {
+	if x != nil {
+		return x.Code
+	}
+	return 0
+}
+
+func (x *LoginResponse) GetMessage() string {
+	if x != nil {
+		return x.Message
+	}
+	return ""
+}
+
+func (x *LoginResponse) GetData() *LoginSuccess {
+	if x != nil {
+		return x.Data
+	}
+	return nil
+}
+
+type LogoutRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Token         string                 `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *LogoutRequest) Reset() {
+	*x = LogoutRequest{}
+	mi := &file_auth_proto_msgTypes[3]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *LogoutRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*LogoutRequest) ProtoMessage() {}
+
+func (x *LogoutRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_auth_proto_msgTypes[3]
+	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 LogoutRequest.ProtoReflect.Descriptor instead.
+func (*LogoutRequest) Descriptor() ([]byte, []int) {
+	return file_auth_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *LogoutRequest) GetToken() string {
+	if x != nil {
+		return x.Token
+	}
+	return ""
+}
+
+type LogoutResponse 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"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *LogoutResponse) Reset() {
+	*x = LogoutResponse{}
+	mi := &file_auth_proto_msgTypes[4]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *LogoutResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*LogoutResponse) ProtoMessage() {}
+
+func (x *LogoutResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_auth_proto_msgTypes[4]
+	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 LogoutResponse.ProtoReflect.Descriptor instead.
+func (*LogoutResponse) Descriptor() ([]byte, []int) {
+	return file_auth_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *LogoutResponse) GetCode() int32 {
+	if x != nil {
+		return x.Code
+	}
+	return 0
+}
+
+func (x *LogoutResponse) GetMessage() string {
+	if x != nil {
+		return x.Message
+	}
+	return ""
+}
+
+type UserInfoRequest struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Token         string                 `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *UserInfoRequest) Reset() {
+	*x = UserInfoRequest{}
+	mi := &file_auth_proto_msgTypes[5]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *UserInfoRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UserInfoRequest) ProtoMessage() {}
+
+func (x *UserInfoRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_auth_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 UserInfoRequest.ProtoReflect.Descriptor instead.
+func (*UserInfoRequest) Descriptor() ([]byte, []int) {
+	return file_auth_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *UserInfoRequest) GetToken() string {
+	if x != nil {
+		return x.Token
+	}
+	return ""
+}
+
+type UserInfo struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Username      string                 `protobuf:"bytes,1,opt,name=username,proto3" json:"username,omitempty"`
+	ExpiresAt     int64                  `protobuf:"varint,2,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"` // Token expiration timestamp
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *UserInfo) Reset() {
+	*x = UserInfo{}
+	mi := &file_auth_proto_msgTypes[6]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *UserInfo) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UserInfo) ProtoMessage() {}
+
+func (x *UserInfo) ProtoReflect() protoreflect.Message {
+	mi := &file_auth_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 UserInfo.ProtoReflect.Descriptor instead.
+func (*UserInfo) Descriptor() ([]byte, []int) {
+	return file_auth_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *UserInfo) GetUsername() string {
+	if x != nil {
+		return x.Username
+	}
+	return ""
+}
+
+func (x *UserInfo) GetExpiresAt() int64 {
+	if x != nil {
+		return x.ExpiresAt
+	}
+	return 0
+}
+
+type UserInfoResponse 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"`
+	Data          *UserInfo              `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *UserInfoResponse) Reset() {
+	*x = UserInfoResponse{}
+	mi := &file_auth_proto_msgTypes[7]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *UserInfoResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*UserInfoResponse) ProtoMessage() {}
+
+func (x *UserInfoResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_auth_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 UserInfoResponse.ProtoReflect.Descriptor instead.
+func (*UserInfoResponse) Descriptor() ([]byte, []int) {
+	return file_auth_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *UserInfoResponse) GetCode() int32 {
+	if x != nil {
+		return x.Code
+	}
+	return 0
+}
+
+func (x *UserInfoResponse) GetMessage() string {
+	if x != nil {
+		return x.Message
+	}
+	return ""
+}
+
+func (x *UserInfoResponse) GetData() *UserInfo {
+	if x != nil {
+		return x.Data
+	}
+	return nil
+}
+
+var File_auth_proto protoreflect.FileDescriptor
+
+const file_auth_proto_rawDesc = "" +
+	"\n" +
+	"\n" +
+	"auth.proto\x12\x02pb\x1a\x1cgoogle/api/annotations.proto\"F\n" +
+	"\fLoginRequest\x12\x1a\n" +
+	"\busername\x18\x01 \x01(\tR\busername\x12\x1a\n" +
+	"\bpassword\x18\x02 \x01(\tR\bpassword\"N\n" +
+	"\fLoginSuccess\x12\x14\n" +
+	"\x05token\x18\x01 \x01(\tR\x05token\x12(\n" +
+	"\buserInfo\x18\x02 \x01(\v2\f.pb.UserInfoR\buserInfo\"c\n" +
+	"\rLoginResponse\x12\x12\n" +
+	"\x04code\x18\x01 \x01(\x05R\x04code\x12\x18\n" +
+	"\amessage\x18\x02 \x01(\tR\amessage\x12$\n" +
+	"\x04data\x18\x03 \x01(\v2\x10.pb.LoginSuccessR\x04data\"%\n" +
+	"\rLogoutRequest\x12\x14\n" +
+	"\x05token\x18\x01 \x01(\tR\x05token\">\n" +
+	"\x0eLogoutResponse\x12\x12\n" +
+	"\x04code\x18\x01 \x01(\x05R\x04code\x12\x18\n" +
+	"\amessage\x18\x02 \x01(\tR\amessage\"'\n" +
+	"\x0fUserInfoRequest\x12\x14\n" +
+	"\x05token\x18\x01 \x01(\tR\x05token\"E\n" +
+	"\bUserInfo\x12\x1a\n" +
+	"\busername\x18\x01 \x01(\tR\busername\x12\x1d\n" +
+	"\n" +
+	"expires_at\x18\x02 \x01(\x03R\texpiresAt\"b\n" +
+	"\x10UserInfoResponse\x12\x12\n" +
+	"\x04code\x18\x01 \x01(\x05R\x04code\x12\x18\n" +
+	"\amessage\x18\x02 \x01(\tR\amessage\x12 \n" +
+	"\x04data\x18\x03 \x01(\v2\f.pb.UserInfoR\x04data2\xf4\x01\n" +
+	"\x04Auth\x12H\n" +
+	"\x05Login\x12\x10.pb.LoginRequest\x1a\x11.pb.LoginResponse\"\x1a\x82\xd3\xe4\x93\x02\x14:\x01*\"\x0f/api/auth/login\x12L\n" +
+	"\x06Logout\x12\x11.pb.LogoutRequest\x1a\x12.pb.LogoutResponse\"\x1b\x82\xd3\xe4\x93\x02\x15:\x01*\"\x10/api/auth/logout\x12T\n" +
+	"\vGetUserInfo\x12\x13.pb.UserInfoRequest\x1a\x14.pb.UserInfoResponse\"\x1a\x82\xd3\xe4\x93\x02\x14\x12\x12/api/auth/userinfoB\x10Z\x0em7s.live/v5/pbb\x06proto3"
+
+var (
+	file_auth_proto_rawDescOnce sync.Once
+	file_auth_proto_rawDescData []byte
+)
+
+func file_auth_proto_rawDescGZIP() []byte {
+	file_auth_proto_rawDescOnce.Do(func() {
+		file_auth_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_auth_proto_rawDesc), len(file_auth_proto_rawDesc)))
+	})
+	return file_auth_proto_rawDescData
+}
+
+var file_auth_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
+var file_auth_proto_goTypes = []any{
+	(*LoginRequest)(nil),     // 0: pb.LoginRequest
+	(*LoginSuccess)(nil),     // 1: pb.LoginSuccess
+	(*LoginResponse)(nil),    // 2: pb.LoginResponse
+	(*LogoutRequest)(nil),    // 3: pb.LogoutRequest
+	(*LogoutResponse)(nil),   // 4: pb.LogoutResponse
+	(*UserInfoRequest)(nil),  // 5: pb.UserInfoRequest
+	(*UserInfo)(nil),         // 6: pb.UserInfo
+	(*UserInfoResponse)(nil), // 7: pb.UserInfoResponse
+}
+var file_auth_proto_depIdxs = []int32{
+	6, // 0: pb.LoginSuccess.userInfo:type_name -> pb.UserInfo
+	1, // 1: pb.LoginResponse.data:type_name -> pb.LoginSuccess
+	6, // 2: pb.UserInfoResponse.data:type_name -> pb.UserInfo
+	0, // 3: pb.Auth.Login:input_type -> pb.LoginRequest
+	3, // 4: pb.Auth.Logout:input_type -> pb.LogoutRequest
+	5, // 5: pb.Auth.GetUserInfo:input_type -> pb.UserInfoRequest
+	2, // 6: pb.Auth.Login:output_type -> pb.LoginResponse
+	4, // 7: pb.Auth.Logout:output_type -> pb.LogoutResponse
+	7, // 8: pb.Auth.GetUserInfo:output_type -> pb.UserInfoResponse
+	6, // [6:9] is the sub-list for method output_type
+	3, // [3:6] 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
+}
+
+func init() { file_auth_proto_init() }
+func file_auth_proto_init() {
+	if File_auth_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_auth_proto_rawDesc), len(file_auth_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   8,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_auth_proto_goTypes,
+		DependencyIndexes: file_auth_proto_depIdxs,
+		MessageInfos:      file_auth_proto_msgTypes,
+	}.Build()
+	File_auth_proto = out.File
+	file_auth_proto_goTypes = nil
+	file_auth_proto_depIdxs = nil
+}

pb/auth.pb.gw.go

@@ -0,0 +1,297 @@
+// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
+// source: auth.proto
+
+/*
+Package pb is a reverse proxy.
+
+It translates gRPC into RESTful JSON APIs.
+*/
+package pb
+
+import (
+	"context"
+	"errors"
+	"io"
+	"net/http"
+
+	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
+	"github.com/grpc-ecosystem/grpc-gateway/v2/utilities"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/grpclog"
+	"google.golang.org/grpc/metadata"
+	"google.golang.org/grpc/status"
+	"google.golang.org/protobuf/proto"
+)
+
+// Suppress "imported and not used" errors
+var (
+	_ codes.Code
+	_ io.Reader
+	_ status.Status
+	_ = errors.New
+	_ = runtime.String
+	_ = utilities.NewDoubleArray
+	_ = metadata.Join
+)
+
+func request_Auth_Login_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq LoginRequest
+		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)
+	}
+	if req.Body != nil {
+		_, _ = io.Copy(io.Discard, req.Body)
+	}
+	msg, err := client.Login(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_Auth_Login_0(ctx context.Context, marshaler runtime.Marshaler, server AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq LoginRequest
+		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.Login(ctx, &protoReq)
+	return msg, metadata, err
+}
+
+func request_Auth_Logout_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq LogoutRequest
+		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)
+	}
+	if req.Body != nil {
+		_, _ = io.Copy(io.Discard, req.Body)
+	}
+	msg, err := client.Logout(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_Auth_Logout_0(ctx context.Context, marshaler runtime.Marshaler, server AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq LogoutRequest
+		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.Logout(ctx, &protoReq)
+	return msg, metadata, err
+}
+
+var filter_Auth_GetUserInfo_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+
+func request_Auth_GetUserInfo_0(ctx context.Context, marshaler runtime.Marshaler, client AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq UserInfoRequest
+		metadata runtime.ServerMetadata
+	)
+	if req.Body != nil {
+		_, _ = 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_Auth_GetUserInfo_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	msg, err := client.GetUserInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_Auth_GetUserInfo_0(ctx context.Context, marshaler runtime.Marshaler, server AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq UserInfoRequest
+		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_Auth_GetUserInfo_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	msg, err := server.GetUserInfo(ctx, &protoReq)
+	return msg, metadata, err
+}
+
+// RegisterAuthHandlerServer registers the http handlers for service Auth to "mux".
+// UnaryRPC     :call AuthServer 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 RegisterAuthHandlerFromEndpoint 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 RegisterAuthHandlerServer(ctx context.Context, mux *runtime.ServeMux, server AuthServer) error {
+	mux.Handle(http.MethodPost, pattern_Auth_Login_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, "/pb.Auth/Login", runtime.WithHTTPPathPattern("/api/auth/login"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Auth_Login_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_Auth_Login_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodPost, pattern_Auth_Logout_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, "/pb.Auth/Logout", runtime.WithHTTPPathPattern("/api/auth/logout"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Auth_Logout_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_Auth_Logout_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodGet, pattern_Auth_GetUserInfo_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, "/pb.Auth/GetUserInfo", runtime.WithHTTPPathPattern("/api/auth/userinfo"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Auth_GetUserInfo_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_Auth_GetUserInfo_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+
+	return nil
+}
+
+// RegisterAuthHandlerFromEndpoint is same as RegisterAuthHandler but
+// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
+func RegisterAuthHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
+	conn, err := grpc.NewClient(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)
+			}
+			return
+		}
+		go func() {
+			<-ctx.Done()
+			if cerr := conn.Close(); cerr != nil {
+				grpclog.Errorf("Failed to close conn to %s: %v", endpoint, cerr)
+			}
+		}()
+	}()
+	return RegisterAuthHandler(ctx, mux, conn)
+}
+
+// RegisterAuthHandler registers the http handlers for service Auth to "mux".
+// The handlers forward requests to the grpc endpoint over "conn".
+func RegisterAuthHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
+	return RegisterAuthHandlerClient(ctx, mux, NewAuthClient(conn))
+}
+
+// RegisterAuthHandlerClient registers the http handlers for service Auth
+// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "AuthClient".
+// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "AuthClient"
+// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
+// "AuthClient" to call the correct interceptors. This client ignores the HTTP middlewares.
+func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, client AuthClient) error {
+	mux.Handle(http.MethodPost, pattern_Auth_Login_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, "/pb.Auth/Login", runtime.WithHTTPPathPattern("/api/auth/login"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Auth_Login_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		forward_Auth_Login_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodPost, pattern_Auth_Logout_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, "/pb.Auth/Logout", runtime.WithHTTPPathPattern("/api/auth/logout"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Auth_Logout_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		forward_Auth_Logout_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodGet, pattern_Auth_GetUserInfo_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, "/pb.Auth/GetUserInfo", runtime.WithHTTPPathPattern("/api/auth/userinfo"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Auth_GetUserInfo_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		forward_Auth_GetUserInfo_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	return nil
+}
+
+var (
+	pattern_Auth_Login_0       = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "auth", "login"}, ""))
+	pattern_Auth_Logout_0      = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "auth", "logout"}, ""))
+	pattern_Auth_GetUserInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "auth", "userinfo"}, ""))
+)
+
+var (
+	forward_Auth_Login_0       = runtime.ForwardResponseMessage
+	forward_Auth_Logout_0      = runtime.ForwardResponseMessage
+	forward_Auth_GetUserInfo_0 = runtime.ForwardResponseMessage
+)

pb/auth.proto

@@ -0,0 +1,65 @@
+syntax = "proto3";
+package pb;
+option go_package = "m7s.live/v5/pb";
+
+import "google/api/annotations.proto";
+
+message LoginRequest {
+  string username = 1;
+  string password = 2;
+}
+
+message LoginSuccess {
+  string token = 1;
+  UserInfo userInfo = 2;
+}
+
+message LoginResponse {
+  int32 code = 1;
+  string message = 2;
+  LoginSuccess data = 3;
+}
+
+message LogoutRequest {
+  string token = 1;
+}
+
+message LogoutResponse {
+  int32 code = 1;
+  string message = 2;
+}
+
+message UserInfoRequest {
+  string token = 1;
+}
+
+message UserInfo {
+  string username = 1;
+  int64 expires_at = 2;  // Token expiration timestamp
+}
+
+message UserInfoResponse {
+  int32 code = 1;
+  string message = 2;
+  UserInfo data = 3;
+}
+
+service Auth {
+  rpc Login(LoginRequest) returns (LoginResponse) {
+    option (google.api.http) = {
+      post: "/api/auth/login"
+      body: "*"
+    };
+  }
+  rpc Logout(LogoutRequest) returns (LogoutResponse) {
+    option (google.api.http) = {
+      post: "/api/auth/logout"
+      body: "*"
+    };
+  }
+  rpc GetUserInfo(UserInfoRequest) returns (UserInfoResponse) {
+    option (google.api.http) = {
+      get: "/api/auth/userinfo"
+    };
+  }
+} 

pb/auth_grpc.pb.go

@@ -0,0 +1,197 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.5.1
+// - protoc             v6.31.1
+// source: auth.proto
+
+package pb
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+// 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.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	Auth_Login_FullMethodName       = "/pb.Auth/Login"
+	Auth_Logout_FullMethodName      = "/pb.Auth/Logout"
+	Auth_GetUserInfo_FullMethodName = "/pb.Auth/GetUserInfo"
+)
+
+// AuthClient is the client API for Auth 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 AuthClient interface {
+	Login(ctx context.Context, in *LoginRequest, opts ...grpc.CallOption) (*LoginResponse, error)
+	Logout(ctx context.Context, in *LogoutRequest, opts ...grpc.CallOption) (*LogoutResponse, error)
+	GetUserInfo(ctx context.Context, in *UserInfoRequest, opts ...grpc.CallOption) (*UserInfoResponse, error)
+}
+
+type authClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewAuthClient(cc grpc.ClientConnInterface) AuthClient {
+	return &authClient{cc}
+}
+
+func (c *authClient) Login(ctx context.Context, in *LoginRequest, opts ...grpc.CallOption) (*LoginResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(LoginResponse)
+	err := c.cc.Invoke(ctx, Auth_Login_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *authClient) Logout(ctx context.Context, in *LogoutRequest, opts ...grpc.CallOption) (*LogoutResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(LogoutResponse)
+	err := c.cc.Invoke(ctx, Auth_Logout_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *authClient) GetUserInfo(ctx context.Context, in *UserInfoRequest, opts ...grpc.CallOption) (*UserInfoResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(UserInfoResponse)
+	err := c.cc.Invoke(ctx, Auth_GetUserInfo_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// AuthServer is the server API for Auth service.
+// All implementations must embed UnimplementedAuthServer
+// for forward compatibility.
+type AuthServer interface {
+	Login(context.Context, *LoginRequest) (*LoginResponse, error)
+	Logout(context.Context, *LogoutRequest) (*LogoutResponse, error)
+	GetUserInfo(context.Context, *UserInfoRequest) (*UserInfoResponse, error)
+	mustEmbedUnimplementedAuthServer()
+}
+
+// UnimplementedAuthServer 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 UnimplementedAuthServer struct{}
+
+func (UnimplementedAuthServer) Login(context.Context, *LoginRequest) (*LoginResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Login not implemented")
+}
+func (UnimplementedAuthServer) Logout(context.Context, *LogoutRequest) (*LogoutResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Logout not implemented")
+}
+func (UnimplementedAuthServer) GetUserInfo(context.Context, *UserInfoRequest) (*UserInfoResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetUserInfo not implemented")
+}
+func (UnimplementedAuthServer) mustEmbedUnimplementedAuthServer() {}
+func (UnimplementedAuthServer) testEmbeddedByValue()              {}
+
+// UnsafeAuthServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to AuthServer will
+// result in compilation errors.
+type UnsafeAuthServer interface {
+	mustEmbedUnimplementedAuthServer()
+}
+
+func RegisterAuthServer(s grpc.ServiceRegistrar, srv AuthServer) {
+	// If the following call pancis, it indicates UnimplementedAuthServer 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(&Auth_ServiceDesc, srv)
+}
+
+func _Auth_Login_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(LoginRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).Login(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Auth_Login_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).Login(ctx, req.(*LoginRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Auth_Logout_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(LogoutRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).Logout(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Auth_Logout_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).Logout(ctx, req.(*LogoutRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Auth_GetUserInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UserInfoRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).GetUserInfo(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Auth_GetUserInfo_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).GetUserInfo(ctx, req.(*UserInfoRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// Auth_ServiceDesc is the grpc.ServiceDesc for Auth service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var Auth_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "pb.Auth",
+	HandlerType: (*AuthServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Login",
+			Handler:    _Auth_Login_Handler,
+		},
+		{
+			MethodName: "Logout",
+			Handler:    _Auth_Logout_Handler,
+		},
+		{
+			MethodName: "GetUserInfo",
+			Handler:    _Auth_GetUserInfo_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "auth.proto",
+}

pb/global.proto

@@ -13,6 +13,11 @@ service api {
       get: "/api/sysinfo"
     };
   }
+  rpc DisabledPlugins (google.protobuf.Empty) returns (DisabledPluginsResponse) {
+    option (google.api.http) = {
+      get: "/api/plugins/disabled"
+    };
+  }
   rpc Summary (google.protobuf.Empty) returns (SummaryResponse) {
     option (google.api.http) = {
       get: "/api/summary"
@@ -20,12 +25,12 @@ service api {
   }
   rpc Shutdown (RequestWithId) returns (SuccessResponse) {
     option (google.api.http) = {
-      post: "/api/shutdown/{id}"
+      post: "/api/shutdown"
     };
   }
   rpc Restart (RequestWithId) returns (SuccessResponse) {
     option (google.api.http) = {
-      post: "/api/restart/{id}"
+      post: "/api/restart"
     };
   }
   rpc TaskTree (google.protobuf.Empty) returns (TaskTreeResponse) {
@@ -126,6 +131,17 @@ service api {
       body: "*"
     };
   }
+  rpc GetConfigFile (google.protobuf.Empty) returns (GetConfigFileResponse) {
+    option (google.api.http) = {
+      get: "/api/config/file"
+    };
+  }
+  rpc UpdateConfigFile (UpdateConfigFileRequest) returns (SuccessResponse) {
+    option (google.api.http) = {
+      post: "/api/config/file/update"
+      body: "content"
+    };
+  }
   rpc GetConfig (GetConfigRequest) returns (GetConfigResponse) {
     option (google.api.http) = {
       get: "/api/config/get/{name}"
@@ -136,32 +152,65 @@ service api {
       get: "/api/config/formily/{name}"
     };
   }
-  rpc ModifyConfig (ModifyConfigRequest) returns (SuccessResponse) {
+
+  rpc GetPullProxyList (google.protobuf.Empty) returns (PullProxyListResponse) {
     option (google.api.http) = {
-      post: "/api/config/modify/{name}"
-      body: "yaml"
+      get: "/api/proxy/pull/list"
+      additional_bindings {
+        get: "/api/device/list"
+      }
     };
   }
-  rpc GetDeviceList (google.protobuf.Empty) returns (DeviceListResponse) {
+  rpc AddPullProxy (PullProxyInfo) returns (SuccessResponse) {
     option (google.api.http) = {
-      get: "/api/device/list"
+      post: "/api/proxy/pull/add"
+      body: "*"
+      additional_bindings {
+        post: "/api/device/add"
+        body: "*"
+      }
     };
   }
-  rpc AddDevice (DeviceInfo) returns (SuccessResponse) {
+  rpc RemovePullProxy (RequestWithId) returns (SuccessResponse) {
     option (google.api.http) = {
-      post: "/api/device/add"
+      post: "/api/proxy/pull/remove/{id}"
+      body: "*"
+      additional_bindings {
+        post: "/api/device/remove/{id}"
+        body: "*"
+      }
+    };
+  }
+  rpc UpdatePullProxy (UpdatePullProxyRequest) returns (SuccessResponse) {
+    option (google.api.http) = {
+      post: "/api/proxy/pull/update"
+      body: "*"
+      additional_bindings {
+        post: "/api/device/update"
+        body: "*"
+      }
+    };
+  }
+  rpc GetPushProxyList (google.protobuf.Empty) returns (PushProxyListResponse) {
+    option (google.api.http) = {
+      get: "/api/proxy/push/list"
+    };
+  }
+  rpc AddPushProxy (PushProxyInfo) returns (SuccessResponse) {
+    option (google.api.http) = {
+      post: "/api/proxy/push/add"
       body: "*"
     };
   }
-  rpc RemoveDevice (RequestWithId) returns (SuccessResponse) {
+  rpc RemovePushProxy (RequestWithId) returns (SuccessResponse) {
     option (google.api.http) = {
-      post: "/api/device/remove/{id}"
+      post: "/api/proxy/push/remove/{id}"
       body: "*"
     };
   }
-  rpc UpdateDevice (DeviceInfo) returns (SuccessResponse) {
+  rpc UpdatePushProxy (UpdatePushProxyRequest) returns (SuccessResponse) {
     option (google.api.http) = {
-      post: "/api/device/update"
+      post: "/api/proxy/push/update"
       body: "*"
     };
   }
@@ -170,6 +219,55 @@ service api {
       get: "/api/record/list"
     };
   }
+  rpc GetTransformList (google.protobuf.Empty) returns (TransformListResponse) {
+    option (google.api.http) = {
+      get: "/api/transform/list"
+    };
+  }
+  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"
+    };
+  }
+  rpc DeleteRecord (ReqRecordDelete) returns (ResponseDelete) {
+    option (google.api.http) = {
+      post: "/api/record/{type}/delete/{streamPath=**}"
+      body: "*"
+    };
+  }
+  rpc GetAlarmList (AlarmListRequest) returns (AlarmListResponse) {
+    option (google.api.http) = {
+      get: "/api/alarm/list"
+    };
+  }
+  rpc GetSubscriptionProgress (StreamSnapRequest) returns (SubscriptionProgressResponse) {
+    option (google.api.http) = {
+      get: "/api/stream/progress/{streamPath=**}"
+    };
+  }
+  
+  rpc StartPull (GlobalPullRequest) returns (SuccessResponse) {
+    option (google.api.http) = {
+      post: "/api/stream/pull"
+      body: "*"
+    };
+  }
+}
+
+message DisabledPluginsResponse {
+  int32 code = 1;
+  string message = 2;
+  repeated PluginInfo data = 3;
 }
 
 message GetConfigRequest {
@@ -188,12 +286,28 @@ message FormilyResponse {
   map<string, Formily> properties = 2;
 }
 
-message GetConfigResponse {
+message ConfigData {
   string file = 1;
   string modified = 2;
   string merged = 3;
 }
 
+message GetConfigFileResponse {
+  uint32 code = 1;
+  string message = 2;
+  string data = 3;
+}
+
+message GetConfigResponse {
+  uint32 code = 1;
+  string message = 2;
+  ConfigData data = 3;
+}
+
+message UpdateConfigFileRequest {
+  string content = 1;
+}
+
 message ModifyConfigRequest {
   string name = 1;
   string yaml = 2;
@@ -230,19 +344,21 @@ message SummaryResponse {
 
 message PluginInfo {
   string name = 1;
-  string version = 2;
-  bool disabled = 3;
+  repeated string pushAddr = 2;
+  repeated string playAddr = 3;
+  map<string, string> description = 4;
 }
 
 message SysInfoData  {
   google.protobuf.Timestamp startTime = 1;
   string localIP = 2;
-  string version = 3;
-  string goVersion = 4;
-  string os = 5;
-  string arch = 6;
-  int32 cpus = 7;
-  repeated PluginInfo plugins = 8;
+  string publicIP = 3;
+  string version = 4;
+  string goVersion = 5;
+  string os = 6;
+  string arch = 7;
+  int32 cpus = 8;
+  repeated PluginInfo plugins = 9;
 }
 
 message SysInfoResponse {
@@ -261,6 +377,9 @@ message TaskTreeData {
   uint32 state = 7;
   TaskTreeData blocked = 8;
   uint64 pointer = 9;
+  string startReason = 10;
+  bool eventLoopRunning = 11;
+  uint32 level = 12;
 }
 
 message TaskTreeResponse {
@@ -312,6 +431,16 @@ message StreamInfo {
   float speed = 12;
   google.protobuf.Duration bufferTime = 13;
   bool stopOnIdle = 14;
+  repeated RecordingDetail recording = 15;
+}
+
+message RecordingDetail {
+  string filePath = 1;
+  string mode = 2;
+  google.protobuf.Duration fragment = 3;
+  bool append = 4;
+  string pluginName = 5;
+  uint64 pointer = 6;
 }
 
 message Wrap {
@@ -343,9 +472,10 @@ message AudioTrackInfo {
   string delta = 2;
   string meta = 3;
   uint32 bps = 4;
-  uint32 fps = 5;
-  uint32 sampleRate = 6;
-  uint32 channels =7;
+  uint32 bps_out = 5;
+  uint32 fps = 6;
+  uint32 sampleRate = 7;
+  uint32 channels =8;
 }
 
 message TrackSnapShotData {
@@ -366,10 +496,11 @@ message VideoTrackInfo {
   string delta = 2;
   string meta = 3;
   uint32 bps = 4;
-  uint32 fps = 5;
-  uint32 width = 6;
-  uint32 height =7;
-  uint32 gop = 8;
+  uint32 bps_out = 5;
+  uint32 fps = 6;
+  uint32 width = 7;
+  uint32 height =8;
+  uint32 gop = 9;
 }
 
 message SuccessResponse {
@@ -402,6 +533,7 @@ message RingReaderSnapShot {
   uint32 timestamp = 2;
   uint32 delay = 3;
   int32 state = 4;
+  uint32 bps = 5;
 }
 
 message SubscriberSnapShot {
@@ -427,13 +559,13 @@ message SubscribersResponse {
   repeated SubscriberSnapShot data = 6;
 }
 
-message DeviceListResponse {
+message PullProxyListResponse {
   int32 code = 1;
   string message = 2;
-  repeated DeviceInfo data = 3;
+  repeated PullProxyInfo data = 3;
 }
 
-message DeviceInfo {
+message PullProxyInfo {
   uint32 ID = 1;
   google.protobuf.Timestamp createTime = 2;
   google.protobuf.Timestamp updateTime = 3; // 更新时间
@@ -451,8 +583,63 @@ message DeviceInfo {
   google.protobuf.Duration recordFragment = 14; // 录制片段长度
   uint32 rtt = 15; // 平均RTT
   string streamPath = 16; // 流路径
+  google.protobuf.Duration checkInterval = 17; // 检查间隔
 }
 
+message UpdatePullProxyRequest {
+  uint32 ID = 1;
+  optional uint32 parentID = 2; // 父设备ID
+  optional string name = 3; // 设备名称
+  optional string type = 4; // 设备类型
+  optional uint32 status = 5; // 设备状态
+  optional string pullURL = 6; // 拉流地址
+  optional bool pullOnStart = 7; // 启动时拉流
+  optional bool stopOnIdle = 8; // 空闲时停止拉流
+  optional bool audio = 9; // 是否拉取音频
+  optional string description = 10; // 设备描述
+  optional string recordPath = 11; // 录制路径
+  optional google.protobuf.Duration recordFragment = 12; // 录制片段长度
+  optional string streamPath = 13; // 流路径
+  optional google.protobuf.Duration checkInterval = 14; // 检查间隔
+}
+
+message PushProxyInfo {
+  uint32 ID = 1;
+  google.protobuf.Timestamp createTime = 2;
+  google.protobuf.Timestamp updateTime = 3;
+  uint32 parentID = 4; // 父设备ID
+  string name = 5; // 设备名称
+  string type = 6; // 设备类型
+  uint32 status = 7; // 设备状态
+  string pushURL = 8; // 推流地址
+  bool pushOnStart = 9; // 启动时推流
+  bool audio = 10; // 是否推音频
+  string description = 11; // 设备描述
+  uint32 rtt = 12; // 平均RTT
+  string streamPath = 13; // 流路径
+}
+
+message UpdatePushProxyRequest {
+  uint32 ID = 1;
+  optional uint32 parentID = 2; // 父设备ID
+  optional string name = 3; // 设备名称
+  optional string type = 4; // 设备类型
+  optional uint32 status = 5; // 设备状态
+  optional string pushURL = 6; // 推流地址
+  optional bool pushOnStart = 7; // 启动时推流
+  optional bool audio = 8; // 是否推音频
+  optional string description = 9; // 设备描述
+  optional uint32 rtt = 10; // 平均RTT
+  optional string streamPath = 11; // 流路径
+}
+
+message PushProxyListResponse {
+  int32 code = 1;
+  string message = 2;
+  repeated PushProxyInfo data = 3;
+}
+
+
 message SetStreamAliasRequest {
   string streamPath = 1;
   string alias = 2;
@@ -486,10 +673,203 @@ message Recording {
   string streamPath = 1;
   google.protobuf.Timestamp startTime = 2;
   string type = 3;
+  uint64 pointer = 4;
 }
 
 message RecordingListResponse {
   int32 code = 1;
   string message = 2;
   repeated Recording data = 3;
+}
+
+message PushInfo {
+  string streamPath = 1;
+  string targetURL = 2;
+  google.protobuf.Timestamp startTime = 3;
+  string status = 4;
+}
+
+message PushListResponse {
+  int32 code = 1;
+  string message = 2;
+  repeated PushInfo data = 3;
+}
+
+message AddPushRequest {
+  string streamPath = 1;
+  string targetURL = 2;
+}
+
+message Transform {
+  string streamPath = 1;
+  string target = 2;
+  string pluginName = 3;
+  string config = 4;
+}
+
+message TransformListResponse {
+  int32 code = 1;
+  string message = 2;
+  repeated Transform data = 3;
+}
+
+message ReqRecordList {
+  string streamPath = 1;
+  string range = 2;
+  string start = 3;
+  string end = 4;
+  uint32 pageNum = 5;
+  uint32 pageSize = 6;
+  string type = 7;
+  string eventLevel = 8;
+}
+
+message RecordFile {
+  uint32 id = 1;
+  string filePath = 2;
+  string streamPath = 3;
+  google.protobuf.Timestamp startTime = 4;
+  google.protobuf.Timestamp endTime = 5;
+}
+
+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;
+  uint32 pageNum = 4;
+  uint32 pageSize = 5;
+  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;
+  google.protobuf.Timestamp startTime = 3;
+  google.protobuf.Timestamp endTime = 4;
+}
+
+message ResponseCatalog {
+  int32 code = 1;
+  string message = 2;
+  repeated Catalog data = 3;
+}
+
+message ReqRecordDelete {
+  string streamPath = 1;
+  repeated uint32 ids = 2;
+  string startTime = 3;
+  string endTime = 4;
+  string range = 5;
+  string type = 6;
+}
+
+message ResponseDelete {
+  int32 code = 1;
+  string message = 2;
+  repeated RecordFile data = 3;
+}
+
+message ReqRecordCatalog {
+  string type = 1;
+}
+
+message AlarmInfo {
+  uint32 id = 1;
+  string serverInfo = 2;
+  string streamName = 3;
+  string streamPath = 4;
+  string alarmDesc = 5;
+  string alarmName = 6;
+  int32 alarmType = 7;
+  bool isSent = 8;
+  string filePath = 9;
+  google.protobuf.Timestamp createdAt = 10;
+  google.protobuf.Timestamp updatedAt = 11;
+}
+
+message AlarmListRequest {
+  int32 pageNum = 1;
+  int32 pageSize = 2;
+  string range = 3;
+  string start = 4;
+  string end = 5;
+  int32 alarmType = 6;
+  string streamPath = 7;
+  string streamName = 8;
+}
+
+message AlarmListResponse {
+  int32 code = 1;
+  string message = 2;
+  int32 total = 3;
+  int32 pageNum = 4;
+  int32 pageSize = 5;
+  repeated AlarmInfo data = 6;
+}
+
+message Step {
+  string name = 1;
+  string description = 2;
+  string error = 3;
+  google.protobuf.Timestamp startedAt = 4;
+  google.protobuf.Timestamp completedAt = 5;
+}
+
+message SubscriptionProgressData {
+  repeated Step steps = 1;
+  int32 currentStep = 2;
+}
+
+message SubscriptionProgressResponse {
+  int32 code = 1;
+  string message = 2;
+  SubscriptionProgressData data = 3;
+}
+
+message GlobalPullRequest {
+  string remoteURL = 1;
+  string protocol = 2;
+  int32 testMode = 3; // 0: pull, 1: pull without publish
+  string streamPath = 4; // 流路径
+  optional int32 loop = 22; // 拉流循环次数,-1:无限循环
+  
+  // Publish configuration
+  optional bool pubAudio = 5;
+  optional bool pubVideo = 6;
+  optional google.protobuf.Duration delayCloseTimeout = 7; // 延迟自动关闭（无订阅时）
+  optional double speed = 8; // 发送速率
+  optional int32 maxCount = 9; // 最大发布者数量
+  optional bool kickExist = 10; // 是否踢掉已经存在的发布者
+  optional google.protobuf.Duration publishTimeout = 11; // 发布无数据超时
+  optional google.protobuf.Duration waitCloseTimeout = 12; // 延迟自动关闭（等待重连）
+  optional google.protobuf.Duration idleTimeout = 13; // 空闲(无订阅)超时
+  optional google.protobuf.Duration pauseTimeout = 14; // 暂停超时时间
+  optional google.protobuf.Duration bufferTime = 15; // 缓冲时长，0代表取最近关键帧
+  optional double scale = 16; // 缩放倍数
+  optional int32 maxFPS = 17; // 最大FPS
+  optional string key = 18; // 发布鉴权key
+  optional string relayMode = 19; // 转发模式
+  optional string pubType = 20; // 发布类型
+  optional bool dump = 21; // 是否dump
 }

pkg/adts.go

@@ -1,90 +0,0 @@
-package pkg
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"time"
-
-	"github.com/deepch/vdk/codec/aacparser"
-	"m7s.live/v5/pkg/codec"
-	"m7s.live/v5/pkg/util"
-)
-
-var _ IAVFrame = (*ADTS)(nil)
-
-type ADTS struct {
-	DTS time.Duration
-	util.RecyclableMemory
-}
-
-func (A *ADTS) Parse(track *AVTrack) (err error) {
-	if track.ICodecCtx == nil {
-		var ctx = &codec.AACCtx{}
-		var reader = A.NewReader()
-		var adts []byte
-		adts, err = reader.ReadBytes(7)
-		if err != nil {
-			return err
-		}
-		var hdrlen, framelen, samples int
-		ctx.Config, hdrlen, framelen, samples, err = aacparser.ParseADTSHeader(adts)
-		if err != nil {
-			return err
-		}
-		b := &bytes.Buffer{}
-		aacparser.WriteMPEG4AudioConfig(b, ctx.Config)
-		ctx.ConfigBytes = b.Bytes()
-		track.ICodecCtx = ctx
-		track.Info("ADTS", "hdrlen", hdrlen, "framelen", framelen, "samples", samples)
-	}
-	track.Value.Raw, err = A.Demux(track.ICodecCtx)
-	return
-}
-
-func (A *ADTS) ConvertCtx(ctx codec.ICodecCtx) (codec.ICodecCtx, IAVFrame, error) {
-	return ctx.GetBase(), nil, nil
-}
-
-func (A *ADTS) Demux(ctx codec.ICodecCtx) (any, error) {
-	var reader = A.NewReader()
-	err := reader.Skip(7)
-	var mem util.Memory
-	reader.Range(mem.AppendOne)
-	return mem, err
-}
-
-func (A *ADTS) Mux(ctx codec.ICodecCtx, frame *AVFrame) {
-	A.InitRecycleIndexes(1)
-	A.DTS = frame.Timestamp * 90 / time.Millisecond
-	aacCtx, ok := ctx.GetBase().(*codec.AACCtx)
-	if !ok {
-		A.Append(frame.Raw.(util.Memory).Buffers...)
-		return
-	}
-	adts := A.NextN(7)
-	raw := frame.Raw.(util.Memory)
-	aacparser.FillADTSHeader(adts, aacCtx.Config, raw.Size/aacCtx.GetSampleSize(), raw.Size)
-	A.Append(raw.Buffers...)
-}
-
-func (A *ADTS) GetTimestamp() time.Duration {
-	return A.DTS * time.Millisecond / 90
-}
-
-func (A *ADTS) GetCTS() time.Duration {
-	return 0
-}
-
-func (A *ADTS) GetSize() int {
-	return A.Size
-}
-
-func (A *ADTS) String() string {
-	return fmt.Sprintf("ADTS{size:%d}", A.Size)
-}
-
-func (A *ADTS) Dump(b byte, writer io.Writer) {
-	//TODO implement me
-	panic("implement me")
-}

pkg/annexb.go

@@ -1,177 +0,0 @@
-package pkg
-
-import (
-	"encoding/binary"
-	"fmt"
-	"io"
-	"time"
-
-	"github.com/deepch/vdk/codec/h264parser"
-	"github.com/deepch/vdk/codec/h265parser"
-
-	"m7s.live/v5/pkg/codec"
-	"m7s.live/v5/pkg/util"
-)
-
-var _ IAVFrame = (*AnnexB)(nil)
-
-type AnnexB struct {
-	Hevc bool
-	PTS  time.Duration
-	DTS  time.Duration
-	util.RecyclableMemory
-}
-
-func (a *AnnexB) Dump(t byte, w io.Writer) {
-	m := a.GetAllocator().Borrow(4 + a.Size)
-	binary.BigEndian.PutUint32(m, uint32(a.Size))
-	a.CopyTo(m[4:])
-	w.Write(m)
-}
-
-// DecodeConfig implements pkg.IAVFrame.
-func (a *AnnexB) ConvertCtx(ctx codec.ICodecCtx) (codec.ICodecCtx, IAVFrame, error) {
-	return ctx.GetBase(), nil, nil
-}
-
-// GetSize implements pkg.IAVFrame.
-func (a *AnnexB) GetSize() int {
-	return a.Size
-}
-
-func (a *AnnexB) GetTimestamp() time.Duration {
-	return a.DTS * time.Millisecond / 90
-}
-
-func (a *AnnexB) GetCTS() time.Duration {
-	return (a.PTS - a.DTS) * time.Millisecond / 90
-}
-
-// Parse implements pkg.IAVFrame.
-func (a *AnnexB) Parse(t *AVTrack) (err error) {
-	if a.Hevc {
-		if t.ICodecCtx == nil {
-			t.ICodecCtx = &codec.H265Ctx{}
-		}
-	} else {
-		if t.ICodecCtx == nil {
-			t.ICodecCtx = &codec.H264Ctx{}
-		}
-	}
-	if t.Value.Raw, err = a.Demux(t.ICodecCtx); err != nil {
-		return
-	}
-	for _, nalu := range t.Value.Raw.(Nalus) {
-		if a.Hevc {
-			ctx := t.ICodecCtx.(*codec.H265Ctx)
-			switch codec.ParseH265NALUType(nalu.Buffers[0][0]) {
-			case h265parser.NAL_UNIT_VPS:
-				ctx.RecordInfo.VPS = [][]byte{nalu.ToBytes()}
-			case h265parser.NAL_UNIT_SPS:
-				ctx.RecordInfo.SPS = [][]byte{nalu.ToBytes()}
-			case h265parser.NAL_UNIT_PPS:
-				ctx.RecordInfo.PPS = [][]byte{nalu.ToBytes()}
-				ctx.CodecData, err = h265parser.NewCodecDataFromVPSAndSPSAndPPS(ctx.VPS(), ctx.SPS(), ctx.PPS())
-			case h265parser.NAL_UNIT_CODED_SLICE_BLA_W_LP,
-				h265parser.NAL_UNIT_CODED_SLICE_BLA_W_RADL,
-				h265parser.NAL_UNIT_CODED_SLICE_BLA_N_LP,
-				h265parser.NAL_UNIT_CODED_SLICE_IDR_W_RADL,
-				h265parser.NAL_UNIT_CODED_SLICE_IDR_N_LP,
-				h265parser.NAL_UNIT_CODED_SLICE_CRA:
-				t.Value.IDR = true
-			}
-		} else {
-			ctx := t.ICodecCtx.(*codec.H264Ctx)
-			switch codec.ParseH264NALUType(nalu.Buffers[0][0]) {
-			case codec.NALU_SPS:
-				ctx.RecordInfo.SPS = [][]byte{nalu.ToBytes()}
-			case codec.NALU_PPS:
-				ctx.RecordInfo.PPS = [][]byte{nalu.ToBytes()}
-				ctx.CodecData, err = h264parser.NewCodecDataFromSPSAndPPS(ctx.SPS(), ctx.PPS())
-			case codec.NALU_IDR_Picture:
-				t.Value.IDR = true
-			}
-		}
-	}
-	return
-}
-
-// String implements pkg.IAVFrame.
-func (a *AnnexB) String() string {
-	return fmt.Sprintf("%d %d", a.DTS, a.Memory.Size)
-}
-
-// Demux implements pkg.IAVFrame.
-func (a *AnnexB) Demux(codecCtx codec.ICodecCtx) (ret any, err error) {
-	var nalus Nalus
-	var lastFourBytes [4]byte
-	var b byte
-	var shallow util.Memory
-	shallow.Append(a.Buffers...)
-	reader := shallow.NewReader()
-
-	gotNalu := func() {
-		var nalu util.Memory
-		for buf := range reader.ClipFront {
-			nalu.AppendOne(buf)
-		}
-		nalus = append(nalus, nalu)
-
-	}
-
-	for {
-		b, err = reader.ReadByte()
-		if err == nil {
-			copy(lastFourBytes[:], lastFourBytes[1:])
-			lastFourBytes[3] = b
-			var startCode = 0
-			if lastFourBytes == codec.NALU_Delimiter2 {
-				startCode = 4
-			} else if [3]byte(lastFourBytes[1:]) == codec.NALU_Delimiter1 {
-				startCode = 3
-			}
-			if startCode > 0 {
-				if reader.Offset() == 3 {
-					startCode = 3
-				}
-				reader.Unread(startCode)
-				if reader.Offset() > 0 {
-					gotNalu()
-				}
-				reader.Skip(startCode)
-				for range reader.ClipFront {
-				}
-			}
-		} else if err == io.EOF {
-			if reader.Offset() > 0 {
-				gotNalu()
-			}
-			err = nil
-			break
-		}
-	}
-	ret = nalus
-	return
-}
-
-func (a *AnnexB) Mux(codecCtx codec.ICodecCtx, frame *AVFrame) {
-	a.DTS = frame.Timestamp * 90 / time.Millisecond
-	a.PTS = a.DTS + frame.CTS*90/time.Millisecond
-	a.InitRecycleIndexes(0)
-	delimiter2 := codec.NALU_Delimiter2[:]
-	a.AppendOne(delimiter2)
-	if frame.IDR {
-		switch ctx := codecCtx.(type) {
-		case *codec.H264Ctx:
-			a.Append(ctx.SPS(), delimiter2, ctx.PPS(), delimiter2)
-		case *codec.H265Ctx:
-			a.Append(ctx.SPS(), delimiter2, ctx.PPS(), delimiter2, ctx.VPS(), delimiter2)
-		}
-	}
-	for i, nalu := range frame.Raw.(Nalus) {
-		if i > 0 {
-			a.AppendOne(codec.NALU_Delimiter1[:])
-		}
-		a.Append(nalu.Buffers...)
-	}
-}

pkg/annexb_reader.go

@@ -0,0 +1,219 @@
+package pkg
+
+import (
+	"fmt"
+
+	"github.com/langhuihui/gomem"
+)
+
+// AnnexBReader 专门用于读取 AnnexB 格式数据的读取器
+// 模仿 MemoryReader 结构，支持跨切片读取和动态数据管理
+type AnnexBReader struct {
+	gomem.Memory                 // 存储数据的多段内存
+	Length, offset0, offset1 int // 可读长度和当前读取位置
+}
+
+// AppendBuffer 追加单个数据缓冲区
+func (r *AnnexBReader) AppendBuffer(buf []byte) {
+	r.PushOne(buf)
+	r.Length += len(buf)
+}
+
+// ClipFront 剔除已读取的数据，释放内存
+func (r *AnnexBReader) ClipFront() {
+	readOffset := r.Size - r.Length
+	if readOffset == 0 {
+		return
+	}
+
+	// 剔除已完全读取的缓冲区（不回收内存）
+	if r.offset0 > 0 {
+		r.Buffers = r.Buffers[r.offset0:]
+		r.Size -= readOffset
+		r.offset0 = 0
+	}
+
+	// 处理部分读取的缓冲区（不回收内存）
+	if r.offset1 > 0 && len(r.Buffers) > 0 {
+		buf := r.Buffers[0]
+		r.Buffers[0] = buf[r.offset1:]
+		r.Size -= r.offset1
+		r.offset1 = 0
+	}
+}
+
+// FindStartCode 查找 NALU 起始码，返回起始码位置和长度
+func (r *AnnexBReader) FindStartCode() (pos int, startCodeLen int, found bool) {
+	if r.Length < 3 {
+		return 0, 0, false
+	}
+
+	// 逐字节检查起始码
+	for i := 0; i <= r.Length-3; i++ {
+		// 优先检查 4 字节起始码
+		if i <= r.Length-4 {
+			if r.getByteAt(i) == 0x00 && r.getByteAt(i+1) == 0x00 &&
+				r.getByteAt(i+2) == 0x00 && r.getByteAt(i+3) == 0x01 {
+				return i, 4, true
+			}
+		}
+
+		// 检查 3 字节起始码（但要确保不是 4 字节起始码的一部分）
+		if r.getByteAt(i) == 0x00 && r.getByteAt(i+1) == 0x00 && r.getByteAt(i+2) == 0x01 {
+			// 确保这不是4字节起始码的一部分
+			if i == 0 || r.getByteAt(i-1) != 0x00 {
+				return i, 3, true
+			}
+		}
+	}
+
+	return 0, 0, false
+}
+
+// getByteAt 获取指定位置的字节，不改变读取位置
+func (r *AnnexBReader) getByteAt(pos int) byte {
+	if pos >= r.Length {
+		return 0
+	}
+
+	// 计算在哪个缓冲区和缓冲区内的位置
+	currentPos := 0
+	bufferIndex := r.offset0
+	bufferOffset := r.offset1
+
+	for bufferIndex < len(r.Buffers) {
+		buf := r.Buffers[bufferIndex]
+		available := len(buf) - bufferOffset
+
+		if currentPos+available > pos {
+			// 目标位置在当前缓冲区内
+			return buf[bufferOffset+(pos-currentPos)]
+		}
+
+		currentPos += available
+		bufferIndex++
+		bufferOffset = 0
+	}
+
+	return 0
+}
+
+type InvalidDataError struct {
+	gomem.Memory
+}
+
+func (e InvalidDataError) Error() string {
+	return fmt.Sprintf("% 02X", e.ToBytes())
+}
+
+// ReadNALU 读取一个完整的 NALU
+// withStart 用于接收“包含起始码”的内存段
+// withoutStart 用于接收“不包含起始码”的内存段
+// 允许 withStart 或 withoutStart 为 nil（表示调用方不需要该形式的数据）
+func (r *AnnexBReader) ReadNALU(withStart, withoutStart *gomem.Memory) error {
+	r.ClipFront()
+	// 定位到第一个起始码
+	firstPos, startCodeLen, found := r.FindStartCode()
+	if !found {
+		return nil
+	}
+
+	// 跳过起始码之前的无效数据
+	if firstPos > 0 {
+		var invalidData gomem.Memory
+		var reader gomem.MemoryReader
+		reader.Memory = &r.Memory
+		reader.RangeN(firstPos, invalidData.PushOne)
+		return InvalidDataError{invalidData}
+	}
+
+	// 为了查找下一个起始码，需要临时跳过当前起始码再查找
+	saveOffset0, saveOffset1, saveLength := r.offset0, r.offset1, r.Length
+	r.forward(startCodeLen)
+	nextPosAfterStart, _, nextFound := r.FindStartCode()
+	// 恢复到起始码起点
+	r.offset0, r.offset1, r.Length = saveOffset0, saveOffset1, saveLength
+	if !nextFound {
+		return nil
+	}
+
+	// 依次读取并填充输出，同时推进读取位置到 NALU 末尾（不消耗下一个起始码）
+	remaining := startCodeLen + nextPosAfterStart
+	// 需要在 withoutStart 中跳过的前缀（即起始码长度）
+	skipForWithout := startCodeLen
+
+	for remaining > 0 && r.offset0 < len(r.Buffers) {
+		buf := r.getCurrentBuffer()
+		readLen := len(buf)
+		if readLen > remaining {
+			readLen = remaining
+		}
+		segment := buf[:readLen]
+
+		if withStart != nil {
+			withStart.PushOne(segment)
+		}
+
+		if withoutStart != nil {
+			if skipForWithout >= readLen {
+				// 本段全部属于起始码，跳过
+				skipForWithout -= readLen
+			} else {
+				// 仅跳过起始码前缀，余下推入 withoutStart
+				withoutStart.PushOne(segment[skipForWithout:])
+				skipForWithout = 0
+			}
+		}
+
+		if readLen == len(buf) {
+			r.skipCurrentBuffer()
+		} else {
+			r.forward(readLen)
+		}
+		remaining -= readLen
+	}
+
+	return nil
+}
+
+// getCurrentBuffer 获取当前读取位置的缓冲区
+func (r *AnnexBReader) getCurrentBuffer() []byte {
+	if r.offset0 >= len(r.Buffers) {
+		return nil
+	}
+	return r.Buffers[r.offset0][r.offset1:]
+}
+
+// forward 向前移动读取位置
+func (r *AnnexBReader) forward(n int) {
+	if n <= 0 || r.Length <= 0 {
+		return
+	}
+	if n > r.Length { // 防御：不允许超出剩余长度
+		n = r.Length
+	}
+	r.Length -= n
+	for n > 0 && r.offset0 < len(r.Buffers) {
+		cur := r.Buffers[r.offset0]
+		remain := len(cur) - r.offset1
+		if n < remain { // 仍在当前缓冲区内
+			r.offset1 += n
+			n = 0
+			return
+		}
+		// 用掉当前缓冲区剩余部分，跳到下一个缓冲区起点
+		n -= remain
+		r.offset0++
+		r.offset1 = 0
+	}
+}
+
+// skipCurrentBuffer 跳过当前缓冲区
+func (r *AnnexBReader) skipCurrentBuffer() {
+	if r.offset0 < len(r.Buffers) {
+		curBufLen := len(r.Buffers[r.offset0]) - r.offset1
+		r.Length -= curBufLen
+		r.offset0++
+		r.offset1 = 0
+	}
+}

pkg/annexb_reader_test.go

@@ -0,0 +1,173 @@
+package pkg
+
+import (
+	"bytes"
+	_ "embed"
+	"math/rand"
+	"testing"
+
+	"github.com/langhuihui/gomem"
+	"m7s.live/v5/pkg/codec"
+)
+
+func bytesFromMemory(m gomem.Memory) []byte {
+	if m.Size == 0 {
+		return nil
+	}
+	out := make([]byte, 0, m.Size)
+	for _, b := range m.Buffers {
+		out = append(out, b...)
+	}
+	return out
+}
+
+func TestAnnexBReader_ReadNALU_Basic(t *testing.T) {
+
+	var reader AnnexBReader
+
+	// 3 个 NALU，分别使用 4 字节、3 字节、4 字节起始码
+	expected1 := []byte{0x67, 0x42, 0x00, 0x1E}
+	expected2 := []byte{0x68, 0xCE, 0x3C, 0x80}
+	expected3 := []byte{0x65, 0x88, 0x84, 0x00}
+
+	buf := append([]byte{0x00, 0x00, 0x00, 0x01}, expected1...)
+	buf = append(buf, append([]byte{0x00, 0x00, 0x01}, expected2...)...)
+	buf = append(buf, append([]byte{0x00, 0x00, 0x00, 0x01}, expected3...)...)
+
+	reader.AppendBuffer(append(buf, codec.NALU_Delimiter2[:]...))
+
+	// 读取并校验 3 个 NALU（不包含起始码）
+	var n gomem.Memory
+	if err := reader.ReadNALU(nil, &n); err != nil {
+		t.Fatalf("read nalu 1: %v", err)
+	}
+	if !bytes.Equal(bytesFromMemory(n), expected1) {
+		t.Fatalf("nalu1 mismatch")
+	}
+
+	n = gomem.Memory{}
+	if err := reader.ReadNALU(nil, &n); err != nil {
+		t.Fatalf("read nalu 2: %v", err)
+	}
+	if !bytes.Equal(bytesFromMemory(n), expected2) {
+		t.Fatalf("nalu2 mismatch")
+	}
+
+	n = gomem.Memory{}
+	if err := reader.ReadNALU(nil, &n); err != nil {
+		t.Fatalf("read nalu 3: %v", err)
+	}
+	if !bytes.Equal(bytesFromMemory(n), expected3) {
+		t.Fatalf("nalu3 mismatch")
+	}
+
+	// 再读一次应无更多起始码，返回 nil 错误且长度为 0
+	if err := reader.ReadNALU(nil, &n); err != nil {
+		t.Fatalf("expected nil error when no more nalu, got: %v", err)
+	}
+	if reader.Length != 4 {
+		t.Fatalf("expected length 0 after reading all, got %d", reader.Length)
+	}
+}
+
+func TestAnnexBReader_AppendBuffer_MultiChunk_Random(t *testing.T) {
+
+	var reader AnnexBReader
+
+	rng := rand.New(rand.NewSource(1)) // 固定种子，保证可复现
+
+	// 生成随机 NALU（仅负载部分），并构造 AnnexB 数据（随机 3/4 字节起始码）
+	numNALU := 12
+	expectedPayloads := make([][]byte, 0, numNALU)
+	fullStream := make([]byte, 0, 1024)
+
+	for i := 0; i < numNALU; i++ {
+		payloadLen := 1 + rng.Intn(32)
+		payload := make([]byte, payloadLen)
+		for j := 0; j < payloadLen; j++ {
+			payload[j] = byte(rng.Intn(256))
+		}
+		expectedPayloads = append(expectedPayloads, payload)
+
+		if rng.Intn(2) == 0 {
+			fullStream = append(fullStream, 0x00, 0x00, 0x01)
+		} else {
+			fullStream = append(fullStream, 0x00, 0x00, 0x00, 0x01)
+		}
+		fullStream = append(fullStream, payload...)
+	}
+	fullStream = append(fullStream, codec.NALU_Delimiter2[:]...) // 结尾加个起始码，方便读取到最后一个 NALU
+	// 随机切割为多段并 AppendBuffer
+	for i := 0; i < len(fullStream); {
+		// 每段长度 1..7 字节（或剩余长度）
+		maxStep := 7
+		remain := len(fullStream) - i
+		step := 1 + rng.Intn(maxStep)
+		if step > remain {
+			step = remain
+		}
+		reader.AppendBuffer(fullStream[i : i+step])
+		i += step
+	}
+
+	// 依次读取并校验
+	for idx, expected := range expectedPayloads {
+		var n gomem.Memory
+		if err := reader.ReadNALU(nil, &n); err != nil {
+			t.Fatalf("read nalu %d: %v", idx+1, err)
+		}
+		got := bytesFromMemory(n)
+		if !bytes.Equal(got, expected) {
+			t.Fatalf("nalu %d mismatch: expected %d bytes, got %d bytes", idx+1, len(expected), len(got))
+		}
+	}
+
+	// 没有更多 NALU
+	var n gomem.Memory
+	if err := reader.ReadNALU(nil, &n); err != nil {
+		t.Fatalf("expected nil error when no more nalu, got: %v", err)
+	}
+}
+
+// 起始码跨越两个缓冲区的情况测试（例如 00 00 | 00 01）
+func TestAnnexBReader_StartCodeAcrossBuffers(t *testing.T) {
+	var reader AnnexBReader
+	// 构造一个 4 字节起始码被拆成两段的情况，后跟一个短 payload
+	reader.AppendBuffer([]byte{0x00, 0x00})
+	reader.AppendBuffer([]byte{0x00})
+	reader.AppendBuffer([]byte{0x01, 0x11, 0x22, 0x33}) // payload: 11 22 33
+	reader.AppendBuffer(codec.NALU_Delimiter2[:])
+	var n gomem.Memory
+	if err := reader.ReadNALU(nil, &n); err != nil {
+		t.Fatalf("read nalu: %v", err)
+	}
+	got := bytesFromMemory(n)
+	expected := []byte{0x11, 0x22, 0x33}
+	if !bytes.Equal(got, expected) {
+		t.Fatalf("payload mismatch: expected %v got %v", expected, got)
+	}
+}
+
+//go:embed test.h264
+var annexbH264Sample []byte
+
+var clipSizesH264 = [...]int{7823, 7157, 5137, 6268, 5958, 4573, 5661, 5589, 3917, 5207, 5347, 4111, 4755, 5199, 3761, 5014, 4981, 3736, 5075, 4889, 3739, 4701, 4655, 3471, 4086, 4428, 3309, 4388, 28, 8, 63974, 63976, 37544, 4945, 6525, 6974, 4874, 6317, 6141, 4455, 5833, 4105, 5407, 5479, 3741, 5142, 4939, 3745, 4945, 4857, 3518, 4624, 4930, 3649, 4846, 5020, 3293, 4588, 4571, 3430, 4844, 4822, 21223, 8461, 7188, 4882, 6108, 5870, 4432, 5389, 5466, 3726}
+
+func TestAnnexBReader_EmbeddedAnnexB_H265(t *testing.T) {
+	var reader AnnexBReader
+	offset := 0
+	for _, size := range clipSizesH264 {
+		reader.AppendBuffer(annexbH264Sample[offset : offset+size])
+		offset += size
+		var nalu gomem.Memory
+		if err := reader.ReadNALU(nil, &nalu); err != nil {
+			t.Fatalf("read nalu: %v", err)
+		} else {
+			t.Logf("read nalu: %d bytes", nalu.Size)
+			if nalu.Size > 0 {
+				tryH264Type := codec.ParseH264NALUType(nalu.Buffers[0][0])
+				t.Logf("tryH264Type: %d", tryH264Type)
+			}
+		}
+	}
+}

pkg/auth/auth.go

@@ -0,0 +1,86 @@
+package auth
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+)
+
+var (
+	jwtSecret = []byte("m7s_secret_key") // In production, this should be properly configured
+	tokenTTL  = 24 * time.Hour
+	// Add refresh threshold - refresh token if it expires in less than 30 minutes
+	refreshThreshold = 30 * time.Minute
+)
+
+// JWTClaims represents the JWT claims
+type JWTClaims struct {
+	Username string `json:"username"`
+}
+
+// TokenValidator is an interface for token validation
+type TokenValidator interface {
+	ValidateToken(tokenString string) (*JWTClaims, error)
+}
+
+// GenerateToken generates a new JWT token for a user
+func GenerateToken(username string) (string, error) {
+	claims := jwt.RegisteredClaims{
+		Subject:   username,
+		ExpiresAt: jwt.NewNumericDate(time.Now().Add(tokenTTL)),
+		IssuedAt:  jwt.NewNumericDate(time.Now()),
+		NotBefore: jwt.NewNumericDate(time.Now()),
+	}
+
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	return token.SignedString(jwtSecret)
+}
+
+// ValidateJWT validates a JWT token and returns the claims
+func ValidateJWT(tokenString string) (*JWTClaims, error) {
+	token, err := jwt.ParseWithClaims(tokenString, &jwt.RegisteredClaims{}, func(token *jwt.Token) (interface{}, error) {
+		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
+		}
+		return jwtSecret, nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	if claims, ok := token.Claims.(*jwt.RegisteredClaims); ok && token.Valid {
+		return &JWTClaims{Username: claims.Subject}, nil
+	}
+
+	return nil, errors.New("invalid token")
+}
+
+// ShouldRefreshToken checks if a token should be refreshed based on its expiration time
+func ShouldRefreshToken(tokenString string) (bool, error) {
+	token, err := jwt.ParseWithClaims(tokenString, &jwt.RegisteredClaims{}, func(token *jwt.Token) (interface{}, error) {
+		return jwtSecret, nil
+	})
+	if err != nil {
+		return false, err
+	}
+
+	if claims, ok := token.Claims.(*jwt.RegisteredClaims); ok && token.Valid {
+		if claims.ExpiresAt != nil {
+			timeUntilExpiry := time.Until(claims.ExpiresAt.Time)
+			return timeUntilExpiry < refreshThreshold, nil
+		}
+	}
+	return false, errors.New("invalid token")
+}
+
+// RefreshToken validates the old token and generates a new one if it's still valid
+func RefreshToken(oldToken string) (string, error) {
+	claims, err := ValidateJWT(oldToken)
+	if err != nil {
+		return "", err
+	}
+	return GenerateToken(claims.Username)
+}

pkg/auth/middleware.go

@@ -0,0 +1,49 @@
+package auth
+
+import (
+	"context"
+	"net/http"
+	"strings"
+)
+
+// Middleware creates a new middleware for HTTP authentication
+func Middleware(validator TokenValidator) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			// Skip auth for login endpoint
+			if r.URL.Path == "/api/auth/login" {
+				next.ServeHTTP(w, r)
+				return
+			}
+
+			// Get token from Authorization header
+			authHeader := r.Header.Get("Authorization")
+			if authHeader == "" {
+				http.Error(w, "missing authorization header", http.StatusUnauthorized)
+				return
+			}
+
+			tokenString := strings.TrimPrefix(authHeader, "Bearer ")
+			claims, err := validator.ValidateToken(tokenString)
+			if err != nil {
+				http.Error(w, "invalid token", http.StatusUnauthorized)
+				return
+			}
+
+			// Check if token needs refresh
+			shouldRefresh, err := ShouldRefreshToken(tokenString)
+			if err == nil && shouldRefresh {
+				newToken, err := RefreshToken(tokenString)
+				if err == nil {
+					// Add new token to response headers
+					w.Header().Set("New-Token", newToken)
+					w.Header().Set("Access-Control-Expose-Headers", "New-Token")
+				}
+			}
+
+			// Add claims to context
+			ctx := context.WithValue(r.Context(), "claims", claims)
+			next.ServeHTTP(w, r.WithContext(ctx))
+		})
+	}
+}

pkg/av1_parse_test.go

@@ -0,0 +1,274 @@
+package pkg
+
+import (
+	"testing"
+
+	"github.com/bluenviron/mediacommon/pkg/codecs/av1"
+	"github.com/langhuihui/gomem"
+	"m7s.live/v5/pkg/codec"
+)
+
+// TestParseAV1OBUs tests the ParseAV1OBUs method
+func TestParseAV1OBUs(t *testing.T) {
+	t.Run("empty reader", func(t *testing.T) {
+		sample := &BaseSample{}
+		mem := gomem.Memory{}
+		reader := mem.NewReader()
+
+		err := sample.ParseAV1OBUs(&reader)
+		if err != nil {
+			t.Errorf("Expected no error for empty reader, got: %v", err)
+		}
+	})
+
+	t.Run("single OBU - Sequence Header", func(t *testing.T) {
+		sample := &BaseSample{}
+
+		// Create a simple AV1 OBU (Sequence Header)
+		// OBU Header: type=1 (SEQUENCE_HEADER), extension_flag=0, has_size_field=1
+		obuHeader := byte(0b00001010) // type=1, has_size=1
+		obuSize := byte(4)            // Size of OBU payload
+		payload := []byte{0x08, 0x0C, 0x00, 0x00}
+
+		mem := gomem.Memory{}
+		mem.PushOne([]byte{obuHeader, obuSize})
+		mem.PushOne(payload)
+
+		reader := mem.NewReader()
+		err := sample.ParseAV1OBUs(&reader)
+		if err != nil {
+			t.Errorf("ParseAV1OBUs failed: %v", err)
+		}
+
+		nalus := sample.Raw.(*Nalus)
+		if nalus.Count() != 1 {
+			t.Errorf("Expected 1 OBU, got %d", nalus.Count())
+		}
+	})
+
+	t.Run("multiple OBUs", func(t *testing.T) {
+		sample := &BaseSample{}
+
+		mem := gomem.Memory{}
+
+		// First OBU - Temporal Delimiter
+		obuHeader1 := byte(0b00010010) // type=2 (TEMPORAL_DELIMITER), has_size=1
+		obuSize1 := byte(0)
+		mem.PushOne([]byte{obuHeader1, obuSize1})
+
+		// Second OBU - Frame Header with some payload
+		obuHeader2 := byte(0b00011010) // type=3 (FRAME_HEADER), has_size=1
+		obuSize2 := byte(3)
+		payload2 := []byte{0x01, 0x02, 0x03}
+		mem.PushOne([]byte{obuHeader2, obuSize2})
+		mem.PushOne(payload2)
+
+		reader := mem.NewReader()
+		err := sample.ParseAV1OBUs(&reader)
+		if err != nil {
+			t.Errorf("ParseAV1OBUs failed: %v", err)
+		}
+
+		nalus := sample.Raw.(*Nalus)
+		if nalus.Count() != 2 {
+			t.Errorf("Expected 2 OBUs, got %d", nalus.Count())
+		}
+	})
+}
+
+// TestGetOBUs tests the GetOBUs method
+func TestGetOBUs(t *testing.T) {
+	t.Run("initialize empty OBUs", func(t *testing.T) {
+		sample := &BaseSample{}
+		obus := sample.GetOBUs()
+
+		if obus == nil {
+			t.Error("GetOBUs should return non-nil OBUs")
+		}
+
+		if sample.Raw != obus {
+			t.Error("Raw should be set to the returned OBUs")
+		}
+	})
+
+	t.Run("return existing OBUs", func(t *testing.T) {
+		existingOBUs := &OBUs{}
+		sample := &BaseSample{
+			Raw: existingOBUs,
+		}
+
+		obus := sample.GetOBUs()
+		if obus != existingOBUs {
+			t.Error("GetOBUs should return the existing OBUs")
+		}
+	})
+}
+
+// TestAV1OBUTypes tests all AV1 OBU type constants
+func TestAV1OBUTypes(t *testing.T) {
+	tests := []struct {
+		name     string
+		obuType  int
+		expected int
+	}{
+		{"SEQUENCE_HEADER", codec.AV1_OBU_SEQUENCE_HEADER, 1},
+		{"TEMPORAL_DELIMITER", codec.AV1_OBU_TEMPORAL_DELIMITER, 2},
+		{"FRAME_HEADER", codec.AV1_OBU_FRAME_HEADER, 3},
+		{"TILE_GROUP", codec.AV1_OBU_TILE_GROUP, 4},
+		{"METADATA", codec.AV1_OBU_METADATA, 5},
+		{"FRAME", codec.AV1_OBU_FRAME, 6},
+		{"REDUNDANT_FRAME_HEADER", codec.AV1_OBU_REDUNDANT_FRAME_HEADER, 7},
+		{"TILE_LIST", codec.AV1_OBU_TILE_LIST, 8},
+		{"PADDING", codec.AV1_OBU_PADDING, 15},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.obuType != tt.expected {
+				t.Errorf("OBU type %s: expected %d, got %d", tt.name, tt.expected, tt.obuType)
+			}
+		})
+	}
+}
+
+// TestAV1Integration tests the full integration of AV1 codec
+func TestAV1Integration(t *testing.T) {
+	t.Run("create AV1 context and parse OBUs", func(t *testing.T) {
+		// Create AV1 codec context
+		ctx := &codec.AV1Ctx{
+			ConfigOBUs: []byte{0x0A, 0x0B, 0x00},
+		}
+
+		// Verify context properties
+		if ctx.GetInfo() != "AV1" {
+			t.Errorf("Expected 'AV1', got '%s'", ctx.GetInfo())
+		}
+
+		if ctx.FourCC() != codec.FourCC_AV1 {
+			t.Error("FourCC should be AV1")
+		}
+
+		// Create a sample with OBUs
+		sample := &Sample{
+			ICodecCtx:  ctx,
+			BaseSample: &BaseSample{},
+		}
+
+		// Add some OBUs
+		obus := sample.GetOBUs()
+		obu := obus.GetNextPointer()
+		obu.PushOne([]byte{0x0A, 0x01, 0x02, 0x03})
+
+		// Verify OBU count
+		if obus.Count() != 1 {
+			t.Errorf("Expected 1 OBU, got %d", obus.Count())
+		}
+	})
+}
+
+// TestAV1OBUHeaderParsing tests parsing of actual AV1 OBU headers
+func TestAV1OBUHeaderParsing(t *testing.T) {
+	tests := []struct {
+		name       string
+		headerByte byte
+		obuType    uint
+		hasSize    bool
+	}{
+		{
+			name:       "Sequence Header with size",
+			headerByte: 0b00001010, // type=1, has_size=1
+			obuType:    1,
+			hasSize:    true,
+		},
+		{
+			name:       "Frame with size",
+			headerByte: 0b00110010, // type=6, has_size=1
+			obuType:    6,
+			hasSize:    true,
+		},
+		{
+			name:       "Temporal Delimiter with size",
+			headerByte: 0b00010010, // type=2, has_size=1
+			obuType:    2,
+			hasSize:    true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var header av1.OBUHeader
+			err := header.Unmarshal([]byte{tt.headerByte})
+			if err != nil {
+				t.Fatalf("Failed to unmarshal OBU header: %v", err)
+			}
+
+			if uint(header.Type) != tt.obuType {
+				t.Errorf("Expected OBU type %d, got %d", tt.obuType, header.Type)
+			}
+
+			if header.HasSize != tt.hasSize {
+				t.Errorf("Expected HasSize %v, got %v", tt.hasSize, header.HasSize)
+			}
+		})
+	}
+}
+
+// BenchmarkParseAV1OBUs benchmarks the OBU parsing performance
+func BenchmarkParseAV1OBUs(b *testing.B) {
+	// Prepare test data
+	mem := gomem.Memory{}
+	for i := 0; i < 10; i++ {
+		obuHeader := byte(0b00110010) // Frame OBU
+		obuSize := byte(10)
+		payload := make([]byte, 10)
+		for j := range payload {
+			payload[j] = byte(j)
+		}
+		mem.PushOne([]byte{obuHeader, obuSize})
+		mem.PushOne(payload)
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		sample := &BaseSample{}
+		reader := mem.NewReader()
+		_ = sample.ParseAV1OBUs(&reader)
+	}
+}
+
+// TestOBUsReuseArray tests the reuse array functionality with OBUs
+func TestOBUsReuseArray(t *testing.T) {
+	t.Run("reuse OBU memory", func(t *testing.T) {
+		obus := &OBUs{}
+
+		// First allocation
+		obu1 := obus.GetNextPointer()
+		obu1.PushOne([]byte{1, 2, 3})
+
+		if obus.Count() != 1 {
+			t.Errorf("Expected count 1, got %d", obus.Count())
+		}
+
+		// Second allocation
+		obu2 := obus.GetNextPointer()
+		obu2.PushOne([]byte{4, 5, 6})
+
+		if obus.Count() != 2 {
+			t.Errorf("Expected count 2, got %d", obus.Count())
+		}
+
+		// Reset and reuse
+		obus.Reset()
+		if obus.Count() != 0 {
+			t.Errorf("Expected count 0 after reset, got %d", obus.Count())
+		}
+
+		// Reuse memory
+		obu3 := obus.GetNextPointer()
+		obu3.PushOne([]byte{7, 8, 9})
+
+		if obus.Count() != 1 {
+			t.Errorf("Expected count 1 after reuse, got %d", obus.Count())
+		}
+	})
+}

pkg/av_reader.go

@@ -3,10 +3,11 @@ package pkg
 import (
 	"context"
 	"log/slog"
+	"time"
+
+	"github.com/langhuihui/gotask"
 	"m7s.live/v5/pkg/codec"
 	"m7s.live/v5/pkg/config"
-	"m7s.live/v5/pkg/task"
-	"time"
 )
 
 const (
@@ -36,6 +37,7 @@ type AVRingReader struct {
 	startTime    time.Time
 	AbsTime      uint32
 	Delay        uint32
+	BPS          uint32 // Bytes per second
 }
 
 func (r *AVRingReader) DecConfChanged() bool {
@@ -170,8 +172,11 @@ func (r *AVRingReader) ReadFrame(conf *config.Subscribe) (err error) {
 		}
 	}
 	r.Delay = r.Track.LastValue.Sequence - r.Value.Sequence
+	// fmt.Println(r.Delay)
 	if r.Track.ICodecCtx != nil {
-		r.Log(context.TODO(), task.TraceLevel, r.Track.FourCC().String(), "ts", r.Value.Timestamp, "delay", r.Delay)
+		if r.Logger.Enabled(context.TODO(), task.TraceLevel) {
+			r.Log(context.TODO(), task.TraceLevel, r.Track.FourCC().String(), "ts", r.Value.Timestamp, "delay", r.Delay, "bps", r.BPS)
+		}
 	} else {
 		r.Warn("no codec")
 	}

pkg/avframe.go

@@ -1,12 +1,11 @@
 package pkg
 
 import (
-	"io"
-	"net"
 	"sync"
 	"time"
 
 	"github.com/bluenviron/mediacommon/pkg/codecs/av1"
+	"github.com/langhuihui/gomem"
 	"m7s.live/v5/pkg/codec"
 	"m7s.live/v5/pkg/util"
 )
@@ -27,60 +26,166 @@ type (
 	}
 	// Source -> Parse -> Demux -> (ConvertCtx) -> Mux(GetAllocator) -> Recycle
 	IAVFrame interface {
-		GetAllocator() *util.ScalableMemoryAllocator
-		SetAllocator(*util.ScalableMemoryAllocator)
-		Parse(*AVTrack) error                                          // get codec info, idr
-		ConvertCtx(codec.ICodecCtx) (codec.ICodecCtx, IAVFrame, error) // convert codec from source stream
-		Demux(codec.ICodecCtx) (any, error)                            // demux to raw format
-		Mux(codec.ICodecCtx, *AVFrame)                                 // mux from raw format
-		GetTimestamp() time.Duration
-		GetCTS() time.Duration
+		GetSample() *Sample
 		GetSize() int
+		CheckCodecChange() error
+		Demux() error      // demux to raw format
+		Mux(*Sample) error // mux from origin format
 		Recycle()
 		String() string
-		Dump(byte, io.Writer)
 	}
+	ISequenceCodecCtx[T any] interface {
+		GetSequenceFrame() T
+	}
+	BaseSample struct {
+		Raw                 IRaw // 裸格式用于转换的中间格式
+		IDR                 bool
+		TS0, Timestamp, CTS time.Duration // 原始 TS、修正 TS、Composition Time Stamp
+	}
+	Sample struct {
+		codec.ICodecCtx
+		gomem.RecyclableMemory
+		*BaseSample
+	}
+	Nalus = util.ReuseArray[gomem.Memory]
 
-	Nalus []util.Memory
+	AudioData = gomem.Memory
 
-	AudioData = util.Memory
-
-	OBUs AudioData
+	OBUs = util.ReuseArray[gomem.Memory]
 
 	AVFrame struct {
 		DataFrame
-		IDR       bool
-		Timestamp time.Duration // 绝对时间戳
-		CTS       time.Duration // composition time stamp
-		Wraps     []IAVFrame    // 封装格式
+		*Sample
+		Wraps []IAVFrame // 封装格式
+	}
+	IRaw interface {
+		util.Resetter
+		Count() int
 	}
-
 	AVRing    = util.Ring[AVFrame]
 	DataFrame struct {
 		sync.RWMutex
 		discard   bool
 		Sequence  uint32    // 在一个Track中的序号
 		WriteTime time.Time // 写入时间,可用于比较两个帧的先后
-		Raw       any       // 裸格式
 	}
 )
 
-var _ IAVFrame = (*AnnexB)(nil)
+func (sample *Sample) GetSize() int {
+	return sample.Size
+}
 
-func (frame *AVFrame) Clone() {
+func (sample *Sample) GetSample() *Sample {
+	return sample
+}
 
+func (sample *Sample) CheckCodecChange() (err error) {
+	return
+}
+
+func (sample *Sample) Demux() error {
+	return nil
+}
+
+func (sample *Sample) Mux(from *Sample) error {
+	sample.ICodecCtx = from.GetBase()
+	return nil
+}
+
+func ConvertFrameType(from, to IAVFrame) (err error) {
+	fromSampe, toSample := from.GetSample(), to.GetSample()
+	if !fromSampe.HasRaw() {
+		if err = from.Demux(); err != nil {
+			return
+		}
+	}
+	toSample.SetAllocator(fromSampe.GetAllocator())
+	toSample.BaseSample = fromSampe.BaseSample
+	return to.Mux(fromSampe)
+}
+
+func (b *BaseSample) HasRaw() bool {
+	return b.Raw != nil && b.Raw.Count() > 0
+}
+
+// 90Hz
+func (b *BaseSample) GetDTS() time.Duration {
+	return b.Timestamp * 90 / time.Millisecond
+}
+
+func (b *BaseSample) GetPTS() time.Duration {
+	return (b.Timestamp + b.CTS) * 90 / time.Millisecond
+}
+
+func (b *BaseSample) SetDTS(dts time.Duration) {
+	b.Timestamp = dts * time.Millisecond / 90
+}
+
+func (b *BaseSample) SetPTS(pts time.Duration) {
+	b.CTS = pts*time.Millisecond/90 - b.Timestamp
+}
+
+func (b *BaseSample) SetTS32(ts uint32) {
+	b.Timestamp = time.Duration(ts) * time.Millisecond
+}
+
+func (b *BaseSample) GetTS32() uint32 {
+	return uint32(b.Timestamp / time.Millisecond)
+}
+
+func (b *BaseSample) SetCTS32(ts uint32) {
+	b.CTS = time.Duration(ts) * time.Millisecond
+}
+
+func (b *BaseSample) GetCTS32() uint32 {
+	return uint32(b.CTS / time.Millisecond)
+}
+
+func (b *BaseSample) GetNalus() *Nalus {
+	if b.Raw == nil {
+		b.Raw = &Nalus{}
+	}
+	return b.Raw.(*Nalus)
+}
+
+func (b *BaseSample) GetOBUs() *OBUs {
+	if b.Raw == nil {
+		b.Raw = &OBUs{}
+	}
+	return b.Raw.(*OBUs)
+}
+
+func (b *BaseSample) GetAudioData() *AudioData {
+	if b.Raw == nil {
+		b.Raw = &AudioData{}
+	}
+	return b.Raw.(*AudioData)
+}
+
+func (b *BaseSample) ParseAVCC(reader *gomem.MemoryReader, naluSizeLen int) error {
+	array := b.GetNalus()
+	for reader.Length > 0 {
+		l, err := reader.ReadBE(naluSizeLen)
+		if err != nil {
+			return err
+		}
+		reader.RangeN(int(l), array.GetNextPointer().PushOne)
+	}
+	return nil
 }
 
 func (frame *AVFrame) Reset() {
-	frame.Timestamp = 0
-	frame.IDR = false
-	frame.CTS = 0
-	frame.Raw = nil
 	if len(frame.Wraps) > 0 {
 		for _, wrap := range frame.Wraps {
 			wrap.Recycle()
 		}
-		frame.Wraps = frame.Wraps[:0]
+		frame.BaseSample.IDR = false
+		frame.BaseSample.TS0 = 0
+		frame.BaseSample.Timestamp = 0
+		frame.BaseSample.CTS = 0
+		if frame.Raw != nil {
+			frame.Raw.Reset()
+		}
 	}
 }
 
@@ -89,11 +194,6 @@ func (frame *AVFrame) Discard() {
 	frame.Reset()
 }
 
-func (frame *AVFrame) Demux(codecCtx codec.ICodecCtx) (err error) {
-	frame.Raw, err = frame.Wraps[0].Demux(codecCtx)
-	return
-}
-
 func (df *DataFrame) StartWrite() (success bool) {
 	if df.discard {
 		return
@@ -110,56 +210,31 @@ func (df *DataFrame) Ready() {
 	df.Unlock()
 }
 
-func (nalus *Nalus) H264Type() codec.H264NALUType {
-	return codec.ParseH264NALUType((*nalus)[0].Buffers[0][0])
-}
-
-func (nalus *Nalus) H265Type() codec.H265NALUType {
-	return codec.ParseH265NALUType((*nalus)[0].Buffers[0][0])
-}
-
-func (nalus *Nalus) Append(bytes []byte) {
-	*nalus = append(*nalus, util.Memory{Buffers: net.Buffers{bytes}, Size: len(bytes)})
-}
-
-func (nalus *Nalus) ParseAVCC(reader *util.MemoryReader, naluSizeLen int) error {
-	for reader.Length > 0 {
-		l, err := reader.ReadBE(naluSizeLen)
-		if err != nil {
-			return err
-		}
-		var mem util.Memory
-		reader.RangeN(int(l), mem.AppendOne)
-		*nalus = append(*nalus, mem)
-	}
-	return nil
-}
-
-func (obus *OBUs) ParseAVCC(reader *util.MemoryReader) error {
+func (b *BaseSample) ParseAV1OBUs(reader *gomem.MemoryReader) error {
 	var obuHeader av1.OBUHeader
 	startLen := reader.Length
 	for reader.Length > 0 {
 		offset := reader.Size - reader.Length
-		b, err := reader.ReadByte()
+		b0, err := reader.ReadByte()
 		if err != nil {
 			return err
 		}
-		err = obuHeader.Unmarshal([]byte{b})
+		err = obuHeader.Unmarshal([]byte{b0})
 		if err != nil {
 			return err
 		}
 		// if log.Trace {
-		// 	vt.Trace("obu", zap.Any("type", obuHeader.Type), zap.Bool("iframe", vt.Value.IFrame))
+		//     vt.Trace("obu", zap.Any("type", obuHeader.Type), zap.Bool("iframe", vt.Value.IFrame))
 		// }
 		obuSize, _, _ := reader.LEB128Unmarshal()
 		end := reader.Size - reader.Length
 		size := end - offset + int(obuSize)
-		reader = &util.MemoryReader{Memory: reader.Memory, Length: startLen - offset}
+		reader = &gomem.MemoryReader{Memory: reader.Memory, Length: startLen - offset}
 		obu, err := reader.ReadBytes(size)
 		if err != nil {
 			return err
 		}
-		(*AudioData)(obus).AppendOne(obu)
+		b.GetNalus().GetNextPointer().PushOne(obu)
 	}
 	return nil
 }

pkg/codec/audio.go

@@ -2,6 +2,7 @@ package codec
 
 import (
 	"fmt"
+
 	"github.com/deepch/vdk/codec/aacparser"
 	"github.com/deepch/vdk/codec/opusparser"
 )
@@ -26,6 +27,32 @@ type (
 	}
 )
 
+func NewAACCtxFromRecord(record []byte) (ret *AACCtx, err error) {
+	ret = &AACCtx{}
+	ret.CodecData, err = aacparser.NewCodecDataFromMPEG4AudioConfigBytes(record)
+	return
+}
+
+func NewPCMACtx() *PCMACtx {
+	return &PCMACtx{
+		AudioCtx: AudioCtx{
+			SampleRate: 90000,
+			Channels:   1,
+			SampleSize: 16,
+		},
+	}
+}
+
+func NewPCMUCtx() *PCMUCtx {
+	return &PCMUCtx{
+		AudioCtx: AudioCtx{
+			SampleRate: 90000,
+			Channels:   1,
+			SampleSize: 16,
+		},
+	}
+}
+
 func (ctx *AudioCtx) GetRecord() []byte {
 	return []byte{}
 }
@@ -58,6 +85,12 @@ func (ctx *AACCtx) GetSampleRate() int {
 func (ctx *AACCtx) GetBase() ICodecCtx {
 	return ctx
 }
+
+func (ctx *AACCtx) String() string {
+	// https://www.w3.org/TR/webcodecs-aac-codec-registration/
+	return fmt.Sprintf("mp4a.40.%d", ctx.Config.ObjectType)
+}
+
 func (ctx *AACCtx) GetRecord() []byte {
 	return ctx.ConfigBytes
 }
@@ -78,9 +111,18 @@ func (ctx *PCMACtx) GetBase() ICodecCtx {
 	return ctx
 }
 
+func (ctx *PCMACtx) String() string {
+	return "alaw"
+}
+
+func (ctx *PCMUCtx) String() string {
+	return "ulaw"
+}
+
 func (ctx *PCMUCtx) GetBase() ICodecCtx {
 	return ctx
 }
+
 func (*PCMUCtx) GetRecord() []byte {
 	return []byte{} //TODO
 }
@@ -95,6 +137,11 @@ func (*OPUSCtx) FourCC() FourCC {
 func (ctx *OPUSCtx) GetBase() ICodecCtx {
 	return ctx
 }
+
+func (ctx *OPUSCtx) String() string {
+	return "opus"
+}
+
 func (ctx *OPUSCtx) GetChannels() int {
 	return ctx.ChannelLayout().Count()
 }

pkg/codec/av1.go

@@ -1,5 +1,7 @@
 package codec
 
+import "fmt"
+
 const (
 	AV1_OBU_SEQUENCE_HEADER        = 1
 	AV1_OBU_TEMPORAL_DELIMITER     = 2
@@ -41,3 +43,7 @@ func (*AV1Ctx) FourCC() FourCC {
 func (ctx *AV1Ctx) GetRecord() []byte {
 	return ctx.ConfigOBUs
 }
+
+func (ctx *AV1Ctx) String() string {
+	return fmt.Sprintf("av01.%02X%02X%02X", ctx.ConfigOBUs[0], ctx.ConfigOBUs[1], ctx.ConfigOBUs[2])
+}

pkg/codec/av1_test.go

@@ -0,0 +1,187 @@
+package codec
+
+import (
+	"testing"
+)
+
+func TestAV1Ctx_GetInfo(t *testing.T) {
+	ctx := &AV1Ctx{
+		ConfigOBUs: []byte{0x0A, 0x0B, 0x00},
+	}
+
+	info := ctx.GetInfo()
+	if info != "AV1" {
+		t.Errorf("Expected 'AV1', got '%s'", info)
+	}
+}
+
+func TestAV1Ctx_GetBase(t *testing.T) {
+	ctx := &AV1Ctx{
+		ConfigOBUs: []byte{0x0A, 0x0B, 0x00},
+	}
+
+	base := ctx.GetBase()
+	if base != ctx {
+		t.Error("GetBase should return itself")
+	}
+}
+
+func TestAV1Ctx_Width(t *testing.T) {
+	ctx := &AV1Ctx{
+		ConfigOBUs: []byte{0x0A, 0x0B, 0x00},
+	}
+
+	width := ctx.Width()
+	if width != 0 {
+		t.Errorf("Expected width 0, got %d", width)
+	}
+}
+
+func TestAV1Ctx_Height(t *testing.T) {
+	ctx := &AV1Ctx{
+		ConfigOBUs: []byte{0x0A, 0x0B, 0x00},
+	}
+
+	height := ctx.Height()
+	if height != 0 {
+		t.Errorf("Expected height 0, got %d", height)
+	}
+}
+
+func TestAV1Ctx_FourCC(t *testing.T) {
+	ctx := &AV1Ctx{}
+
+	fourcc := ctx.FourCC()
+	expected := FourCC_AV1
+	if fourcc != expected {
+		t.Errorf("Expected %v, got %v", expected, fourcc)
+	}
+
+	// Verify the actual FourCC string
+	if fourcc.String() != "av01" {
+		t.Errorf("Expected 'av01', got '%s'", fourcc.String())
+	}
+}
+
+func TestAV1Ctx_GetRecord(t *testing.T) {
+	configOBUs := []byte{0x0A, 0x0B, 0x00, 0x01, 0x02}
+	ctx := &AV1Ctx{
+		ConfigOBUs: configOBUs,
+	}
+
+	record := ctx.GetRecord()
+	if len(record) != len(configOBUs) {
+		t.Errorf("Expected record length %d, got %d", len(configOBUs), len(record))
+	}
+
+	for i, b := range record {
+		if b != configOBUs[i] {
+			t.Errorf("Byte mismatch at index %d: expected %02X, got %02X", i, configOBUs[i], b)
+		}
+	}
+}
+
+func TestAV1Ctx_String(t *testing.T) {
+	tests := []struct {
+		name       string
+		configOBUs []byte
+		expected   string
+	}{
+		{
+			name:       "Standard config",
+			configOBUs: []byte{0x0A, 0x0B, 0x00},
+			expected:   "av01.0A0B00",
+		},
+		{
+			name:       "Different config",
+			configOBUs: []byte{0x08, 0x0C, 0x00},
+			expected:   "av01.080C00",
+		},
+		{
+			name:       "High profile config",
+			configOBUs: []byte{0x0C, 0x10, 0x00},
+			expected:   "av01.0C1000",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := &AV1Ctx{
+				ConfigOBUs: tt.configOBUs,
+			}
+
+			result := ctx.String()
+			if result != tt.expected {
+				t.Errorf("Expected '%s', got '%s'", tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestAV1Ctx_EmptyConfigOBUs(t *testing.T) {
+	ctx := &AV1Ctx{
+		ConfigOBUs: []byte{},
+	}
+
+	// Should not panic when calling methods with empty ConfigOBUs
+	defer func() {
+		if r := recover(); r != nil {
+			t.Errorf("Panic occurred with empty ConfigOBUs: %v", r)
+		}
+	}()
+
+	_ = ctx.GetInfo()
+	_ = ctx.GetBase()
+	_ = ctx.FourCC()
+	_ = ctx.GetRecord()
+	// Note: String() will panic with empty ConfigOBUs due to array indexing
+}
+
+func TestAV1Ctx_NilConfigOBUs(t *testing.T) {
+	ctx := &AV1Ctx{
+		ConfigOBUs: nil,
+	}
+
+	// Should not panic for most methods
+	defer func() {
+		if r := recover(); r != nil {
+			t.Errorf("Panic occurred with nil ConfigOBUs: %v", r)
+		}
+	}()
+
+	_ = ctx.GetInfo()
+	_ = ctx.GetBase()
+	_ = ctx.FourCC()
+
+	record := ctx.GetRecord()
+	if record != nil {
+		t.Error("Expected nil record for nil ConfigOBUs")
+	}
+}
+
+// Test AV1 OBU Type Constants
+func TestAV1_OBUTypeConstants(t *testing.T) {
+	tests := []struct {
+		name     string
+		obuType  int
+		expected int
+	}{
+		{"SEQUENCE_HEADER", AV1_OBU_SEQUENCE_HEADER, 1},
+		{"TEMPORAL_DELIMITER", AV1_OBU_TEMPORAL_DELIMITER, 2},
+		{"FRAME_HEADER", AV1_OBU_FRAME_HEADER, 3},
+		{"TILE_GROUP", AV1_OBU_TILE_GROUP, 4},
+		{"METADATA", AV1_OBU_METADATA, 5},
+		{"FRAME", AV1_OBU_FRAME, 6},
+		{"REDUNDANT_FRAME_HEADER", AV1_OBU_REDUNDANT_FRAME_HEADER, 7},
+		{"TILE_LIST", AV1_OBU_TILE_LIST, 8},
+		{"PADDING", AV1_OBU_PADDING, 15},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.obuType != tt.expected {
+				t.Errorf("Expected OBU type %d, got %d", tt.expected, tt.obuType)
+			}
+		})
+	}
+}

pkg/codec/h264.go

@@ -2,6 +2,7 @@ package codec
 
 import (
 	"fmt"
+
 	"github.com/deepch/vdk/codec/h264parser"
 )
 
@@ -111,6 +112,12 @@ type (
 	}
 )
 
+func NewH264CtxFromRecord(record []byte) (ret *H264Ctx, err error) {
+	ret = &H264Ctx{}
+	ret.CodecData, err = h264parser.NewCodecDataFromAVCDecoderConfRecord(record)
+	return
+}
+
 func (*H264Ctx) FourCC() FourCC {
 	return FourCC_H264
 }
@@ -126,3 +133,7 @@ func (h264 *H264Ctx) GetBase() ICodecCtx {
 func (ctx *H264Ctx) GetRecord() []byte {
 	return ctx.Record
 }
+
+func (h264 *H264Ctx) String() string {
+	return fmt.Sprintf("avc1.%02X%02X%02X", h264.RecordInfo.AVCProfileIndication, h264.RecordInfo.ProfileCompatibility, h264.RecordInfo.AVCLevelIndication)
+}

pkg/codec/h265.go

@@ -1,7 +1,10 @@
 package codec
 
-import "fmt"
-import "github.com/deepch/vdk/codec/h265parser"
+import (
+	"fmt"
+
+	"github.com/deepch/vdk/codec/h265parser"
+)
 
 type H265NALUType byte
 
@@ -21,6 +24,15 @@ type (
 	}
 )
 
+func NewH265CtxFromRecord(record []byte) (ret *H265Ctx, err error) {
+	ret = &H265Ctx{}
+	ret.CodecData, err = h265parser.NewCodecDataFromAVCDecoderConfRecord(record)
+	if err == nil {
+		ret.RecordInfo.LengthSizeMinusOne = 3
+	}
+	return
+}
+
 func (ctx *H265Ctx) GetInfo() string {
 	return fmt.Sprintf("fps: %d, resolution: %s", ctx.FPS(), ctx.Resolution())
 }
@@ -36,3 +48,13 @@ func (h265 *H265Ctx) GetBase() ICodecCtx {
 func (h265 *H265Ctx) GetRecord() []byte {
 	return h265.Record
 }
+
+func (h265 *H265Ctx) String() string {
+	// 根据 HEVC 标准格式：hvc1.profile.compatibility.level.constraints
+	profile := h265.RecordInfo.AVCProfileIndication
+	compatibility := h265.RecordInfo.ProfileCompatibility
+	level := h265.RecordInfo.AVCLevelIndication
+
+	// 简单实现，使用可用字段模拟 HEVC 格式
+	return fmt.Sprintf("hvc1.%d.%X.L%d.00", profile, compatibility, level)
+}

pkg/codec/h26x.go

@@ -0,0 +1,25 @@
+package codec
+
+type H26XCtx struct {
+	VPS, SPS, PPS []byte
+}
+
+func (ctx *H26XCtx) FourCC() (f FourCC) {
+	return
+}
+
+func (ctx *H26XCtx) GetInfo() string {
+	return ""
+}
+
+func (ctx *H26XCtx) GetBase() ICodecCtx {
+	return ctx
+}
+
+func (ctx *H26XCtx) GetRecord() []byte {
+	return nil
+}
+
+func (ctx *H26XCtx) String() string {
+	return ""
+}