Initial commit: Hikvision ISUP Client - Complete C development project

Features:
- ISUP/Ehome protocol platform registration (CMS)
- Video stream management with PS encapsulation
- Recording playback (NET_ESTREAM_StartListenPlayBack + NET_ECMS_StartPlayBack)
- Alarm access (NET_EALARM_StartListen)
- RTMP pushing to ZLMediaKit
- Simulated image/video generation for testing
- Complete configuration management
- Makefile build system
- Deployment scripts
- Comprehensive documentation

Tech stack: C11, Ubuntu 24.04, HCNetSDK, ZLMediaKit, Git/Gogs

.gitignore

@@ -0,0 +1,46 @@
+# Build artifacts
+build/
+*.o
+*.so
+*.a
+*.exe
+hikvision-isup-client
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Logs
+logs/*.log
+*.log
+
+# Config files with secrets
+config_local.ini
+.env
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Temp files
+tmp/
+*.tmp
+
+# HCNetSDK binaries (do not commit)
+libs/*.so
+libs/*.dll
+libs/*.lib
+libs/*.h
+!libs/.gitkeep
+
+# Documentation builds
+docs/_build/
+
+# Coverage
+*.gcov
+*.gcno
+*.gcda
+coverage/

Makefile

@@ -0,0 +1,132 @@
+# ============================================================
+# Hikvision ISUP Client - Makefile
+# ============================================================
+
+# 项目名称
+PROJECT_NAME := hikvision-isup-client
+VERSION := 1.0.0
+
+# 编译器设置
+CC := gcc
+CFLAGS := -Wall -Wextra -std=c11 -g -O2
+CFLAGS += -D_GNU_SOURCE
+CFLAGS += -I./include
+
+# 库路径
+LIB_PATH := ./libs
+HCNETSDK_PATH ?= $(LIB_PATH)
+
+# 目标文件
+TARGET := $(PROJECT_NAME)
+
+# 源文件
+SRCDIR := src
+INCDIR := include
+SOURCES := $(wildcard $(SRCDIR)/*.c)
+OBJECTS := $(patsubst $(SRCDIR)/%.c, $(BUILD_DIR)/%.o, $(SOURCES))
+
+# 构建目录
+BUILD_DIR := build
+
+# HCNetSDK库文件(根据实际部署情况调整)
+# HCNETSDK_LIBS := -lhcnetsdk -lPlayCtrl -lHCPlayCtrl -lHCCommon -lHCWindowsComm -lHCCore
+# 如果没有实际SDK，使用模拟模式编译
+HCNETSDK_LIBS ?=
+
+# 其他依赖库
+OTHER_LIBS := -lpthread -ldl -lm
+
+# 最终链接库
+ALL_LIBS := $(HCNETSDK_LIBS) $(OTHER_LIBS)
+
+# 头文件依赖
+HEADERS := $(wildcard $(INCDIR)/*.h)
+
+# ============================================================
+# 编译目标
+# ============================================================
+
+.PHONY: all clean cleanbuild install test simulate help
+
+all: $(BUILD_DIR) $(TARGET)
+
+# 创建构建目录
+$(BUILD_DIR):
+	mkdir -p $(BUILD_DIR)
+
+# 链接可执行文件
+$(TARGET): $(OBJECTS)
+	$(CC) $(CFLAGS) -o $@ $^ $(ALL_LIBS)
+	@echo "Build complete: $(TARGET)"
+	@echo "Version: $(VERSION)"
+
+# 编译源文件
+$(BUILD_DIR)/%.o: $(SRCDIR)/%.c $(HEADERS)
+	$(CC) $(CFLAGS) -c $< -o $@
+
+# 清理
+clean:
+	rm -rf $(BUILD_DIR) $(TARGET)
+	@echo "Clean complete"
+
+# 清理并重新编译
+cleanbuild: clean all
+	@echo "Clean build complete"
+
+# 安装
+install: $(TARGET)
+	install -d /usr/local/bin
+	install -m 755 $(TARGET) /usr/local/bin/$(TARGET)
+	@echo "Installed to /usr/local/bin/$(TARGET)"
+
+# 测试模式(不链接实际SDK)
+simulate: CFLAGS += -DHAVE_HIKVISION_SIMULATION
+simulate: clean $(BUILD_DIR) $(TARGET)
+	@echo "Simulation build complete (no actual SDK required)"
+
+# 生成依赖文件
+deps: $(HEADERS)
+	$(CC) $(CFLAGS) -MM $(SOURCES) > $(BUILD_DIR)/dependencies.mk
+
+# 帮助
+help:
+	@echo "Hikvision ISUP Client Build System"
+	@echo "=================================="
+	@echo ""
+	@echo "Targets:"
+	@echo "  all         Build the project (default)"
+	@echo "  clean       Remove build artifacts"
+	@echo "  cleanbuild  Clean and rebuild"
+	@echo "  install     Install to /usr/local/bin"
+	@echo "  simulate    Build with simulation mode (no SDK needed)"
+	@echo "  test        Run tests"
+	@echo "  help        Show this help"
+	@echo ""
+	@echo "Variables:"
+	@echo "  HCNETSDK_PATH  Path to HCNetSDK libraries (default: ./libs)"
+	@echo ""
+	@echo "Examples:"
+	@echo "  make                          # Build with SDK"
+	@echo "  make simulate                  # Build without SDK (simulation)"
+	@echo "  make HCNETSDK_PATH=/opt/hik    # Build with custom SDK path"
+	@echo "  make install                   # Install to system"
+
+# 包含依赖文件
+-include $(BUILD_DIR)/dependencies.mk
+
+# ============================================================
+# 部署脚本
+# ============================================================
+
+deploy: all
+	@echo "Deploying $(TARGET)..."
+	./scripts/deploy.sh $(TARGET)
+
+# ============================================================
+# 代码检查
+# ============================================================
+
+check:
+	@echo "Running code checks..."
+	@cppcheck --enable=all --suppress=missingIncludeSystem $(SRCDIR)/*.c 2>&1 || true
+	@echo "Code check complete"

README.md

@@ -0,0 +1,492 @@
+# Hikvision ISUP Client
+
+海康威视 ISUP(Ehome) 协议 C 语言客户端/平台服务端完整开发项目
+
+## 项目概述
+
+本项目是一个基于海康威视 ISUP(Ehome) 协议的完整 C 语言开发框架，实现了以下核心功能：
+
+- **平台注册**：设备通过 ISUP 协议向 CMS 注册服务器注册上线
+- **PS 流推送**：接收海康设备视频流并通过 RTMP 推送到 ZLMediaKit 流媒体服务器
+- **录像回放**：支持通过 NET_ESTREAM_StartListenPlayBack + NET_ECMS_StartPlayBack 实现录像回放
+- **报警接入**：通过 NET_EALARM_StartListen 接收和处理设备报警事件
+- **模拟测试**：内置模拟图片/视频流生成功能，方便开发测试
+
+### 技术栈
+
+| 组件 | 技术选型 | 说明 |
+|------|----------|------|
+| 编程语言 | C11 | 高性能、底层控制 |
+| 操作系统 | Ubuntu 24.04 LTS | 稳定服务器系统 |
+| 海康SDK | HCNetSDK (ISUP/Ehome) | 设备注册/流媒体/报警 |
+| 流媒体 | ZLMediaKit | RTMP/RTSP/HLS 流媒体服务器 |
+| 构建系统 | Make | 简单可靠的构建工具 |
+| 版本控制 | Git + Gogs | 自托管代码管理 |
+
+### 系统架构
+
+```
+┌─────────────┐     ISUP/TCP     ┌──────────────────┐
+│  海康设备    │ ◄──────────────► │  ISUP Client     │
+│  (摄像头/NVR) │   注册/流/报警    │  (本程序)        │
+└─────────────┘                  └────────┬─────────┘
+                                          │ RTMP/PS流
+                                          ▼
+                                   ┌──────────────┐
+                                   │ ZLMediaKit   │
+                                   │ (流媒体服务器) │
+                                   └──────┬───────┘
+                                          │
+                    ┌─────────────────────┼─────────────────────┐
+                    ▼                     ▼                     ▼
+              ┌──────────┐        ┌──────────┐        ┌──────────┐
+              │ RTMP     │        │ HLS      │        │ RTSP     │
+              │ 客户端    │        │ 直播     │        │ 拉流     │
+              └──────────┘        └──────────┘        └──────────┘
+```
+
+## 目录结构
+
+```
+hikvision-isup-client/
+├── README.md              # 项目说明文档
+├── Makefile               # 构建配置文件
+├── config.ini             # 运行配置文件
+├── .gitignore             # Git忽略规则
+├── include/               # 头文件目录
+│   ├── common.h           # 公共定义与常量
+│   ├── config.h           # 配置管理
+│   ├── platform.h         # 平台注册管理
+│   ├── stream.h           # 视频流管理
+│   ├── playback.h         # 录像回放管理
+│   └── alarm.h            # 报警管理
+├── src/                   # 源代码目录
+│   ├── main.c             # 主程序入口
+│   ├── platform.c         # 平台注册实现
+│   ├── stream.c           # 流媒体管理实现
+│   ├── playback.c         # 录像回放实现
+│   ├── alarm.c            # 报警管理实现
+│   ├── config.c           # 配置管理实现
+│   └── utils.c            # 工具函数实现
+├── libs/                  # 第三方库目录
+├── scripts/               # 辅助脚本
+│   ├── setup.sh           # 环境初始化脚本
+│   ├── deploy.sh          # 部署脚本
+│   └── git_sync.sh        # Git同步脚本
+├── docs/                  # 文档目录
+├── tests/                 # 测试目录
+└── logs/                  # 日志目录(运行时生成)
+```
+
+## 环境准备
+
+### 1. 系统要求
+
+- 操作系统：Ubuntu 24.04 LTS (推荐) 或 CentOS 7+
+- 编译器：GCC 9.0+
+- 内存：最低 512MB，推荐 2GB+
+- 磁盘：最低 1GB 可用空间
+
+### 2. 安装依赖
+
+```bash
+# 运行环境初始化脚本
+chmod +x scripts/setup.sh
+./scripts/setup.sh
+```
+
+手动安装依赖：
+
+```bash
+sudo apt-get update
+sudo apt-get install -y build-essential gcc g++ make cmake git pkg-config libssl-dev \
+    ffmpeg libavcodec-dev libavformat-dev libavutil-dev libswscale-dev valgrind cppcheck
+```
+
+### 3. 安装 ZLMediaKit (可选，用于RTMP推流)
+
+```bash
+git clone --depth 1 https://gitee.com/xia-chu/ZLMediaKit
+cd ZLMediaKit
+git submodule update --init
+mkdir build && cd build
+cmake ..
+make -j4
+sudo make install
+```
+
+### 4. 部署 HCNetSDK
+
+从海康威视官网下载 HCNetSDK 包，将 Linux 64位版本的文件复制到 `libs/` 目录：
+
+```
+libs/
+├── libhcnetsdk.so        # 主SDK库
+├── libHCCommon.so        # 公共库
+├── libHCWindowsComm.so   # 通信库
+├── libPlayCtrl.so        # 播放库
+├── libHCNetSDK.so        # 备用SDK库
+└── ...                   # 其他依赖库
+```
+
+## 编译与运行
+
+### 开发模式(无需实际SDK)
+
+```bash
+# 使用模拟模式编译(无需HCNetSDK，可用于开发和测试)
+make simulate
+```
+
+### 正式编译(需要HCNetSDK)
+
+```bash
+# 默认编译(需要libs目录中有HCNetSDK库文件)
+make
+
+# 指定SDK路径
+make HCNETSDK_PATH=/opt/hikvision-sdk
+
+# 清理并重新编译
+make cleanbuild
+```
+
+### 运行程序
+
+```bash
+# 使用默认配置运行
+./hikvision-isup-client
+
+# 指定配置文件
+./hikvision-isup-client -c config.ini
+
+# 守护进程模式运行
+./hikvision-isup-client -c config.ini -d
+
+# 查看帮助
+./hikvision-isup-client -h
+
+# 查看版本
+./hikvision-isup-client -v
+```
+
+### 安装到系统
+
+```bash
+sudo make install
+sudo ./scripts/deploy.sh
+sudo systemctl enable hikvision-isup-client
+sudo systemctl start hikvision-isup-client
+```
+
+## 配置说明
+
+### 设备端配置(海康设备Web页面)
+
+按照以下路径配置海康设备：
+
+```
+系统 > 高级配置 > 网络 > 平台接入 > ISUP(原Ehome)
+```
+
+配置参数如下(与项目 config.ini 对应)：
+
+| 配置项 | 值 | 说明 |
+|--------|-----|------|
+| 平台接入方式 | ISUP(原Ehome) | 选择ISUP协议 |
+| 启用 | 勾选 | 启用平台接入 |
+| 服务器地址 | 117.131.63.98 | 本程序服务器IP |
+| 端口 | 7031 | CMS注册端口 |
+| 设备ID | AX5324540 | 设备序列号 |
+| 注册状态 | 在线 | 确认注册成功 |
+| 协议版本 | ISUP5.0 | 协议版本 |
+| 加密密钥 | abc12345 | 加密密钥 |
+
+### 程序配置(config.ini)
+
+主要配置项说明：
+
+```ini
+[CMS]
+cms_server_ip=117.131.63.98     # CMS服务器IP(本机IP)
+cms_server_port=7031            # CMS监听端口
+device_id=AX5324540             # 设备ID
+protocol_version=ISUP5.0        # 协议版本
+encrypt_key=abc12345            # 加密密钥
+
+[RTMP]
+rtmp_server=127.0.0.1           # ZLMediaKit服务器地址
+rtmp_port=1935                  # RTMP端口
+rtmp_app_name=live              # 应用名称
+rtmp_stream_key=camera1         # 流名称
+```
+
+## 核心API说明
+
+### 平台注册流程
+
+```c
+// 1. 初始化CMS库
+platform_cms_init();
+
+// 2. 启动CMS监听(接收设备注册)
+platform_cms_start_listen("0.0.0.0", 7031, device_register_callback, NULL);
+
+// 3. 设备注册(主动向CMS注册)
+int user_id = platform_device_register("117.131.63.98", 7031,
+    "AX5324540", "ISUP5.0", "abc12345", NULL);
+
+// 4. 设置自动重连
+platform_set_auto_reconnect(user_id, 1, 5);
+
+// 5. 清理
+platform_cms_cleanup();
+```
+
+### 录像回放流程
+
+```c
+// 1. 初始化回放模块
+playback_init();
+
+// 2. 开启SMS回放监听
+stream_start_playback_listen("0.0.0.0", 7660, NULL, NULL);
+
+// 3. 启动回放
+PlaybackSession* session = playback_start(
+    "AX5324540",           // 设备ID
+    1,                     // 通道号
+    start_time,            // 开始时间
+    end_time,              // 结束时间
+    1,                     // 速度(1=正常)
+    playback_data_cb,      // 数据回调
+    playback_status_cb,    // 状态回调
+    NULL                   // 用户数据
+);
+
+// 4. 停止回放
+playback_stop(session);
+
+// 5. 清理
+playback_cleanup();
+```
+
+### 报警接入流程
+
+```c
+// 1. 初始化报警模块
+alarm_init();
+
+// 2. 启动报警监听
+alarm_start_listen("0.0.0.0", 9000,
+    alarm_data_callback,    // 报警数据回调
+    alarm_process_callback, // 报警处理回调
+    NULL);
+
+// 3. 清理
+alarm_cleanup();
+```
+
+### RTMP推流流程
+
+```c
+// 1. 创建流会话
+StreamSession* session = stream_create_session(
+    "AX5324540", STREAM_TYPE_MAIN, CODEC_TYPE_H264,
+    1920, 1080, 25, 4096000
+);
+
+// 2. 开始推流到ZLMediaKit
+stream_start_push(session, "rtmp://127.0.0.1:1935/live/camera1",
+    rtmp_push_callback, NULL);
+
+// 3. 发送视频帧
+StreamFrame frame = { .data = frame_data, .data_size = frame_size, ... };
+stream_send_frame(session, &frame);
+
+// 4. 停止推流
+stream_stop_push(session);
+
+// 5. 销毁会话
+stream_destroy_session(session);
+```
+
+## PS流封装说明
+
+本项目实现了H.264/H.265原始码流到MPEG-2 PS(Program Stream)的封装：
+
+### PS流结构
+
+```
+| Pack Header (4-11 bytes) |
+| Program Stream Map       |
+| PES Packet               |
+|  - PES Header            |
+|  - PES Payload (NALU)    |
+| ...                       |
+| Pack Header              |
+| ...                       |
+```
+
+### 封装流程
+
+1. 从海康设备接收H.264/H.265原始码流
+2. 检测SPS/PPS参数集，如有变化则生成PS系统头和PSMAP
+3. 将NALU数据封装为PES包
+4. 添加Pack Header
+5. 填充到PS_PACKET_SIZE(2048字节)
+6. 添加CRC校验
+7. 通过RTMP推送到ZLMediaKit
+
+### 在ZLMediaKit中接收
+
+ZLMediaKit 支持直接接收ISUP/Ehome协议的PS流，配置方法：
+
+```ini
+# config.ini
+[rtmp]
+port=1935
+
+# ZLMediaKit会自动将RTMP流转换为多种协议输出
+# RTMP: rtmp://server:1935/live/camera1
+# HLS:  http://server:8080/live/camera1.m3u8
+# RTSP: rtsp://server:554/live/camera1
+```
+
+## Git代码管理
+
+### 初始化仓库
+
+```bash
+# 运行Git同步脚本
+chmod +x scripts/git_sync.sh
+./scripts/git_sync.sh
+```
+
+### 手动配置
+
+```bash
+# 初始化git仓库
+git init
+git branch -M main
+
+# 添加远程仓库(使用Access Token)
+git remote add origin "https://steven_roc:1942ce3d6478f7a572fee3dd4891e49f6c416aad@git.zhonjin.com:40717/steven_roc/hikvision-isup-client.git"
+
+# 添加所有文件
+git add -A
+
+# 提交
+git commit -m "Initial commit: Hikvision ISUP Client project"
+
+# 推送
+git push -u origin main
+```
+
+### 日常同步
+
+```bash
+# 方式1: 使用脚本
+./scripts/git_sync.sh
+
+# 方式2: 手动
+git add -A
+git commit -m "描述本次更新内容"
+git push
+```
+
+## 日志说明
+
+程序运行日志输出到 `logs/isup_client.log` 文件和控制台。
+
+日志级别：
+
+| 级别 | 说明 |
+|------|------|
+| DEBUG | 调试信息，详细的内部状态 |
+| INFO | 一般信息，关键流程节点 |
+| WARN | 警告信息，非致命问题 |
+| ERROR | 错误信息，功能异常 |
+| FATAL | 致命错误，程序无法继续 |
+
+修改日志级别：编辑 `config.ini` 中的 `log_level` 参数。
+
+## 故障排查
+
+### 常见问题
+
+**1. 设备注册失败**
+
+- 检查海康设备Web页面配置是否正确(服务器地址、端口、设备ID)
+- 确认防火墙允许7031端口通信
+- 检查加密密钥是否一致
+- 查看程序日志中的错误信息
+
+**2. 视频流无法接收**
+
+- 确认设备已注册上线
+- 检查SMS端口(默认7660)是否可访问
+- 检查HCNetSDK库文件是否正确部署
+- 查看日志中的流相关错误信息
+
+**3. RTMP推流失败**
+
+- 确认ZLMediaKit服务正在运行
+- 检查rtmp_server和rtmp_port配置
+- 使用 `rtmp://server:1935/live/camera1` 测试拉流
+- 查看ZLMediaKit日志
+
+**4. 编译错误**
+
+- 运行 `make simulate` 跳过SDK依赖进行开发
+- 确认GCC版本 >= 9.0
+- 检查 `libs/` 目录中的SDK库文件
+
+### 日志关键字搜索
+
+```bash
+# 搜索注册相关日志
+grep -i "register\|login\|cms" logs/isup_client.log
+
+# 搜索流相关日志
+grep -i "stream\|rtmp\|push" logs/isup_client.log
+
+# 搜索报警相关日志
+grep -i "alarm" logs/isup_client.log
+
+# 搜索错误日志
+grep -i "error\|fail" logs/isup_client.log
+```
+
+## 安全说明
+
+1. **加密密钥管理**：加密密钥等敏感信息不应硬编码在代码中，应通过配置文件或环境变量管理
+2. **访问控制**：生产环境应限制CMS/SMS/Alarm端口的访问来源IP
+3. **日志安全**：日志中可能包含敏感信息，应设置合适的文件权限
+4. **网络安全**：建议在生产环境中使用TLS加密ISUP通信
+
+## 开发计划
+
+- [x] 平台注册(CMS)模块
+- [x] 流媒体管理(SMS)模块
+- [x] 录像回放模块
+- [x] 报警接入模块
+- [x] RTMP推流(ZLMediaKit)
+- [x] 模拟测试模式
+- [x] 配置文件管理
+- [x] 完整文档
+- [ ] 单元测试框架
+- [ ] 性能测试
+- [ ] Docker容器化部署
+- [ ] Web管理界面
+- [ ] 多设备管理
+- [ ] 录像文件管理
+
+## 许可证
+
+本项目为内部开发项目，仅供学习参考使用。
+
+## 联系方式
+
+- Git仓库: https://git.zhonjin.com:40717/steven_roc/hikvision-isup-client
+- 项目维护: steven_roc

config.ini

@@ -0,0 +1,61 @@
+# ============================================================
+# Hikvision ISUP Client Configuration
+# ============================================================
+# 配置文件说明:
+# - 支持 # 和 ; 注释
+# - 格式: key=value
+# - 修改后需重启服务生效
+# ============================================================
+
+# [CMS] 注册服务器配置
+# 对应海康设备Web页面: 系统 > 高级配置 > 网络 > 平台接入 > ISUP
+cms_server_ip=117.131.63.98
+cms_server_port=7031
+device_id=AX5324540
+protocol_version=ISUP5.0
+encrypt_key=abc12345
+enable=1
+auto_reconnect=1
+reconnect_interval=5
+
+# [SMS] 流媒体服务器配置
+sms_listen_ip=0.0.0.0
+sms_listen_port=7660
+max_streams=32
+stream_timeout=30
+
+# [Alarm] 报警服务器配置
+alarm_listen_ip=0.0.0.0
+alarm_listen_port=9000
+alarm_enable=1
+
+# [RTMP] RTMP推流配置(对接zlmediakit)
+rtmp_server=127.0.0.1
+rtmp_port=1935
+rtmp_app_name=live
+rtmp_stream_key=camera1
+rtmp_enable=1
+rtmp_auto_start=1
+rtmp_reconnect=1
+rtmp_reconnect_interval=5
+
+# [Playback] 录像回放配置
+playback_enable=1
+playback_max_concurrent=16
+playback_save_path=./recordings
+playback_record_duration=3600
+
+# [Sim] 模拟配置(开发测试用)
+sim_enable=1
+sim_image_dir=./sim_images
+sim_width=1920
+sim_height=1080
+sim_fps=25
+sim_bitrate=4096000
+sim_gop_size=50
+sim_test_image_count=100
+
+# [General] 通用配置
+log_file=./logs/isup_client.log
+log_level=INFO
+daemon_mode=0

include/alarm.h

@@ -0,0 +1,150 @@
+#ifndef ALARM_H
+#define ALARM_H
+
+/**
+ * @file alarm.h
+ * @brief 报警管理头文件
+ * 
+ * 本文件定义报警事件的接收、处理、转发等功能接口。
+ */
+
+#include "common.h"
+#include "config.h"
+
+/* 报警类型 */
+typedef enum {
+    ALARM_TYPE_MOVEMENT = 0,        /* 移动侦测 */
+    ALARM_TYPE_VI_DETECTION,        /* 视频丢失 */
+    ALARM_TYPE_VI_MASK,             /* 视频遮挡 */
+    ALARM_TYPE_NETWORK_ABNORMAL,    /* 网络异常 */
+    ALARM_TYPE_DISK_ERROR,          /* 硬盘错误 */
+    ALARM_TYPE_IP_CONFLICT,         /* IP冲突 */
+    ALARM_TYPE_STORAGE_EXCEPTION,   /* 存储异常 */
+    ALARM_TYPE_IO_EXCEPTION,        /* IO异常 */
+    ALARM_TYPE_SIZE_OVERFLOW,       /* 容量超限 */
+    ALARM_TYPE_DARKNESS,            /* 场景变更 */
+    ALARM_TYPE_LINE_DETECTION,      /* 越界检测 */
+    ALARM_TYPE_AREA_DETECTION,      /* 区域检测 */
+    ALARM_TYPE_TAMPERING,           /* tampering检测 */
+    ALARM_TYPE_AUDIO_EXCEPTION,     /* 音频异常 */
+    ALARM_TYPE_THERMAL,             /* 热成像报警 */
+    ALARM_TYPE_CUSTOM_START = 1000, /* 自定义报警类型起始 */
+} AlarmType;
+
+/* 报警级别 */
+typedef enum {
+    ALARM_LEVEL_LOW = 0,            /* 低级 */
+    ALARM_LEVEL_MEDIUM,             /* 中级 */
+    ALARM_LEVEL_HIGH,               /* 高级 */
+    ALARM_LEVEL_CRITICAL            /* 严重 */
+} AlarmLevel;
+
+/* 报警信息结构 */
+typedef struct {
+    char     device_id[MAX_DEVICE_ID];  /* 设备ID */
+    int      channel;                     /* 通道号 */
+    AlarmType type;                       /* 报警类型 */
+    AlarmLevel level;                     /* 报警级别 */
+    char     description[256];            /* 报警描述 */
+    char     snapshot_path[MAX_PATH_SIZE];/* 快照路径 */
+    time_t   alarm_time;                  /* 报警时间 */
+    int      alarm_id;                    /* 报警ID */
+    int      duration;                    /* 持续时间(秒) */
+    int      is_acknowledged;             /* 是否已确认 */
+    void*    raw_data;                    /* 原始报警数据 */
+    int      raw_data_size;               /* 原始数据大小 */
+} AlarmInfo;
+
+/* 报警回调函数类型 */
+/*
+ * void (*AlarmDataCB)(AlarmInfo* alarm, void* user_data)
+ * 
+ * alarm:    报警信息结构指针
+ * user_data: 用户自定义数据
+ */
+typedef void (*AlarmDataCB)(AlarmInfo* alarm, void* user_data);
+
+/* 报警处理回调 */
+typedef void (*AlarmProcessCB)(AlarmInfo* alarm, void* user_data);
+
+/**
+ * @brief 初始化报警模块
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ * 
+ * 说明: 初始化报警监听服务，注册报警回调函数。
+ *       对应NET_EALARM_StartListen功能。
+ */
+int alarm_init(void);
+
+/**
+ * @brief 反初始化报警模块
+ * 
+ * 说明: 停止报警监听，释放资源。
+ */
+void alarm_cleanup(void);
+
+/**
+ * @brief 启动报警监听
+ * @param listen_ip 监听IP地址
+ * @param listen_port 监听端口
+ * @param alarm_cb 报警数据回调函数
+ * @param process_cb 报警处理回调函数
+ * @param user_data 用户自定义数据
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ * 
+ * 说明: 启动报警监听服务，开始接收设备上报的报警事件。
+ *       对应NET_EALARM_StartListen功能。
+ *       
+ *       回调函数说明:
+ *       - alarm_cb: 接收到原始报警数据时调用
+ *       - process_cb: 报警数据处理完成后调用(可在业务线程中处理)
+ */
+int alarm_start_listen(const char* listen_ip, short listen_port,
+                       AlarmDataCB alarm_cb, AlarmProcessCB process_cb,
+                       void* user_data);
+
+/**
+ * @brief 停止报警监听
+ * 
+ * 说明: 停止接收报警事件。
+ */
+void alarm_stop_listen(void);
+
+/**
+ * @brief 发送报警确认
+ * @param alarm_id 报警ID
+ * @param device_id 设备ID
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ */
+int alarm_acknowledge(int alarm_id, const char* device_id);
+
+/**
+ * @brief 获取未确认报警列表
+ * @param alarms 输出报警信息数组
+ * @param max_alarms 最大报警数
+ * @return 返回未确认报警数量
+ */
+int alarm_get_unacknowledged(AlarmInfo alarms[], int max_alarms);
+
+/**
+ * @brief 清除已确认的报警
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ */
+int alarm_clear_acknowledged(void);
+
+/**
+ * @brief 注册报警类型过滤器
+ * @param types 要监听的报警类型数组
+ * @param count 类型数量
+ */
+void alarm_register_filter(const AlarmType types[], int count);
+
+/**
+ * @brief 获取报警统计信息
+ * @param total 输出总报警数
+ * @param unack 输出未确认数
+ * @param today 输出今日报警数
+ */
+void alarm_get_stats(int* total, int* unack, int* today);
+
+#endif /* ALARM_H */

include/common.h

@@ -0,0 +1,144 @@
+#ifndef COMMON_H
+#define COMMON_H
+
+/**
+ * @file common.h
+ * @brief 公共定义与常量声明
+ * 
+ * 本文件定义了整个ISUP平台客户端项目的公共常量、宏定义、
+ * 通用数据结构和对齐指令。
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <errno.h>
+#include <time.h>
+#include <stdarg.h>
+
+/* 版本信息 */
+#define PROJECT_NAME        "Hikvision ISUP Client"
+#define PROJECT_VERSION     "1.0.0"
+#define PROJECT_BUILD_DATE  __DATE__ " " __TIME__
+
+/* 日志级别 */
+typedef enum {
+    LOG_LEVEL_DEBUG = 0,
+    LOG_LEVEL_INFO,
+    LOG_LEVEL_WARN,
+    LOG_LEVEL_ERROR,
+    LOG_LEVEL_FATAL
+} LogLevel;
+
+/* 日志宏定义 */
+#define LOG_TAG "ISUP"
+
+#define LOG_PRINT(level, fmt, ...) \
+    do { \
+        fprintf(stderr, "[%s] [%s] [%s:%d:%s()] " fmt "\n", \
+                LOG_TAG, \
+                (level == LOG_LEVEL_DEBUG ? "DEBUG" : \
+                 level == LOG_LEVEL_INFO ? "INFO" : \
+                 level == LOG_LEVEL_WARN ? "WARN" : \
+                 level == LOG_LEVEL_ERROR ? "ERROR" : "FATAL"), \
+                __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
+    } while(0)
+
+#define LOG_DEBUG(fmt, ...) LOG_PRINT(LOG_LEVEL_DEBUG, fmt, ##__VA_ARGS__)
+#define LOG_INFO(fmt, ...)  LOG_PRINT(LOG_LEVEL_INFO, fmt, ##__VA_ARGS__)
+#define LOG_WARN(fmt, ...)  LOG_PRINT(LOG_LEVEL_WARN, fmt, ##__VA_ARGS__)
+#define LOG_ERROR(fmt, ...) LOG_PRINT(LOG_LEVEL_ERROR, fmt, ##__VA_ARGS__)
+#define LOG_FATAL(fmt, ...) LOG_PRINT(LOG_LEVEL_FATAL, fmt, ##__VA_ARGS__)
+
+/* 缓冲区大小 */
+#define MAX_BUF_SIZE        65536
+#define MAX_IP_SIZE         64
+#define MAX_PATH_SIZE       256
+#define MAX_DEVICE_ID       64
+#define MAX_CHANNEL_NUM     32
+#define MAX_ALARM_NUM       128
+#define MAX_PLAYBACK_NUM    16
+#define MAX_STREAM_NUM      32
+
+/* 默认端口配置 */
+#define DEFAULT_CMS_PORT    7031      /* CMS注册服务器端口 */
+#define DEFAULT_SMS_PORT    7660      /* SMS流媒体服务器端口 */
+#define DEFAULT_ALARM_PORT  9000      /* 报警服务器端口 */
+#define DEFAULT_RTMP_PORT   1935      /* RTMP推流端口 */
+#define DEFAULT_HTTP_PORT   8080      /* HTTP管理接口端口 */
+
+/* ISUP协议相关 */
+#define ISUP_PROTO_VERSION  "ISUP5.0"
+#define REG_RETRY_INTERVAL  5         /* 注册重试间隔(秒) */
+#define HEARTBEAT_INTERVAL  30        /* 心跳间隔(秒) */
+#define STREAM_TIMEOUT      30        /* 流超时(秒) */
+
+/* 模拟图片配置 */
+#define SIM_IMAGE_DIR       "./sim_images"
+#define SIM_IMAGE_WIDTH     1920
+#define SIM_IMAGE_HEIGHT    1080
+#define SIM_FPS             25
+#define SIM_BITRATE         4096000   /* 4Mbps */
+
+/* 状态码 */
+#define SUCCESS             0
+#define FAILURE             -1
+#define NOT_FOUND           -2
+#define INVALID_PARAM       -3
+#define TIMEOUT             -4
+#define UNAUTHORIZED        -5
+
+/* 设备状态 */
+typedef enum {
+    DEVICE_STATUS_OFFLINE = 0,
+    DEVICE_STATUS_ONLINE,
+    DEVICE_STATUS_REGISTERS,
+    DEVICE_STATUS_STREAMING,
+    DEVICE_STATUS_PLAYBACK
+} DeviceStatus;
+
+/* 日志函数指针类型 */
+typedef void (*LogCallback)(LogLevel level, const char* tag, const char* fmt, va_list args);
+
+/* 全局日志回调 */
+extern LogCallback g_log_callback;
+
+/**
+ * @brief 设置日志回调函数
+ * @param cb 日志回调函数指针
+ */
+void set_log_callback(LogCallback cb);
+
+/**
+ * @brief 格式化时间戳字符串
+ * @param buf 输出缓冲区
+ * @param bufsize 缓冲区大小
+ * @param fmt 时间格式字符串(strftime格式)
+ * @return 格式化后的字符串指针
+ */
+char* get_timestamp(char* buf, size_t bufsize, const char* fmt);
+
+/**
+ * @brief 字符串转小写
+ * @param str 输入字符串
+ * @return 转换后的字符串指针
+ */
+char* str_tolower(char* str);
+
+/**
+ * @brief 安全字符串复制
+ * @param dest 目标缓冲区
+ * @param src 源字符串
+ * @param size 目标缓冲区大小
+ * @return 复制的字符数
+ */
+size_t safe_strcpy(char* dest, const char* src, size_t size);
+
+#endif /* COMMON_H */

include/config.h

@@ -0,0 +1,144 @@
+#ifndef CONFIG_H
+#define CONFIG_H
+
+/**
+ * @file config.h
+ * @brief 项目配置管理头文件
+ * 
+ * 本文件定义ISUP平台客户端的所有运行时配置参数，
+ * 包括服务器地址、设备信息、流媒体配置等。
+ */
+
+#include "common.h"
+
+/* ============================================================
+ * CMS注册服务器配置
+ * ============================================================ */
+typedef struct {
+    char server_ip[MAX_IP_SIZE];      /* CMS服务器IP地址 */
+    short server_port;                /* CMS服务器端口 */
+    char device_id[MAX_DEVICE_ID];    /* 设备ID(序列号) */
+    char protocol_version[16];        /* 协议版本 */
+    char encrypt_key[32];             /* 加密密钥 */
+    int  enable;                      /* 是否启用 */
+    int  auto_reconnect;              /* 是否自动重连 */
+    int  reconnect_interval;          /* 重连间隔(秒) */
+} CMSConfig;
+
+/* ============================================================
+ * SMS流媒体服务器配置
+ * ============================================================ */
+typedef struct {
+    char listen_ip[MAX_IP_SIZE];      /* 监听IP */
+    short listen_port;                /* 监听端口 */
+    int  max_streams;                 /* 最大流数量 */
+    int  stream_timeout;              /* 流超时时间(秒) */
+} SMSConfig;
+
+/* ============================================================
+ * 报警服务器配置
+ * ============================================================ */
+typedef struct {
+    char listen_ip[MAX_IP_SIZE];      /* 监听IP */
+    short listen_port;                /* 监听端口 */
+    int  enable;                      /* 是否启用 */
+} AlarmConfig;
+
+/* ============================================================
+ * RTMP推流配置(zlmediakit)
+ * ============================================================ */
+typedef struct {
+    char rtmp_server[MAX_IP_SIZE];    /* RTMP服务器地址 */
+    short rtmp_port;                  /* RTMP端口 */
+    char app_name[64];                /* 应用名称 */
+    char stream_key[128];             /* 流密钥/流名称 */
+    int  enable;                      /* 是否启用推流 */
+    int  auto_start;                  /* 设备上线自动推流 */
+    int  reconnect;                   /* 断线重连 */
+    int  reconnect_interval;          /* 重连间隔(秒) */
+} RTMPConfig;
+
+/* ============================================================
+ * 录像回放配置
+ * ============================================================ */
+typedef struct {
+    int  enable;                      /* 是否启用回放 */
+    int  max_concurrent;              /* 最大并发回放数 */
+    char save_path[MAX_PATH_SIZE];    /* 录像保存路径 */
+    int  record_duration;             /* 单次回放最长时长(秒) */
+} PlaybackConfig;
+
+/* ============================================================
+ * 模拟图片/视频配置
+ * ============================================================ */
+typedef struct {
+    int  enable;                      /* 是否启用模拟模式 */
+    char image_dir[MAX_PATH_SIZE];    /* 模拟图片目录 */
+    int  width;                       /* 模拟视频宽度 */
+    int  height;                      /* 模拟视频高度 */
+    int  fps;                         /* 帧率 */
+    int  bitrate;                     /* 码率(bps) */
+    int  gop_size;                    /* GOP大小 */
+    int  test_image_count;            /* 测试图片数量 */
+} SimConfig;
+
+/* ============================================================
+ * 全局配置结构
+ * ============================================================ */
+typedef struct {
+    CMSConfig      cms;               /* CMS注册配置 */
+    SMSConfig      sms;               /* SMS流媒体配置 */
+    AlarmConfig    alarm;             /* 报警配置 */
+    RTMPConfig     rtmp;              /* RTMP推流配置 */
+    PlaybackConfig playback;          /* 录像回放配置 */
+    SimConfig      sim;               /* 模拟配置 */
+    
+    char log_file[MAX_PATH_SIZE];     /* 日志文件路径 */
+    int  log_level;                   /* 日志级别 */
+    int  daemon_mode;                 /* 守护进程模式 */
+    int  pid_file[MAX_PATH_SIZE];     /* PID文件路径 */
+} AppConfig;
+
+/* ============================================================
+ * 配置加载/保存函数声明
+ * ============================================================ */
+
+/**
+ * @brief 加载配置文件
+ * @param config 配置结构指针
+ * @param config_file 配置文件路径
+ * @return SUCCESS成功, FAILURE失败
+ */
+int config_load(AppConfig* config, const char* config_file);
+
+/**
+ * @brief 保存配置到文件
+ * @param config 配置结构指针
+ * @param config_file 配置文件路径
+ * @return SUCCESS成功, FAILURE失败
+ */
+int config_save(const AppConfig* config, const char* config_file);
+
+/**
+ * @brief 使用默认配置初始化
+ * @param config 配置结构指针
+ */
+void config_init_default(AppConfig* config);
+
+/**
+ * @brief 打印配置信息
+ * @param config 配置结构指针
+ */
+void config_print(const AppConfig* config);
+
+/* ============================================================
+ * 默认配置值(与图片中的设备配置对应)
+ * ============================================================
+ * 服务器地址: 117.131.63.98
+ * 端口: 7031
+ * 设备ID: AX5324540
+ * 协议版本: ISUP5.0
+ * 加密密钥: abc12345
+ * ============================================================ */
+
+#endif /* CONFIG_H */

include/platform.h

@@ -0,0 +1,168 @@
+#ifndef PLATFORM_H
+#define PLATFORM_H
+
+/**
+ * @file platform.h
+ * @brief ISUP平台注册管理头文件
+ * 
+ * 本文件定义设备向ISUP平台(CMS)注册、心跳保活、
+ * 登出等核心功能的接口。
+ */
+
+#include "common.h"
+#include "config.h"
+
+/* 设备注册状态回调数据类型 */
+typedef enum {
+    DEV_REG_TYPE_ON = 1,            /* 设备上线 */
+    DEV_REG_TYPE_OFF,               /* 设备下线 */
+    DEV_REG_TYPE_AUTH,              /* 设备认证 */
+    DEV_REG_TYPE_SESSIONKEY,        /* 会话密钥 */
+    DEV_REG_TYPE_ADDRESS_CHANGED,   /* 地址变更 */
+    DEV_REG_TYPE_HEARTBEAT,         /* 心跳 */
+    DEV_REG_TYPE_XMLCONFIG,        /* XML配置 */
+    DEV_REG_TYPE_VTDU_STREAM,      /* VTDU流 */
+} DevRegDataType;
+
+/* 设备注册信息结构 */
+typedef struct {
+    char sDeviceSerial[64];         /* 设备序列号 */
+    char sDeviceID[64];             /* 设备ID */
+    char sDeviceName[128];          /* 设备名称 */
+    char sDeviceType[32];           /* 设备类型 */
+    char sDeviceModel[64];          /* 设备型号 */
+    char sSoftwareVersion[32];      /* 软件版本 */
+    char sHardwareVersion[32];      /* 硬件版本 */
+    char sIPAddress[MAX_IP_SIZE];   /* 设备IP地址 */
+    short sIPAddressType;           /* IP地址类型 */
+    short sPort;                    /* 端口 */
+    int   byChanNum;                /* 模拟通道数 */
+    int   byIPChanNum;              /* 数字通道数 */
+    int   byStartDChan;             /* 起始数字通道号 */
+    int   bySubChanNum;             /* 子通道数 */
+    int   bySupportSubChan;         /* 是否支持子通道 */
+    time_t tOnlineTime;             /* 上线时间 */
+} DevRegInfo;
+
+/* 设备注册回调函数类型 */
+/* 
+ * 原型: void (*DEVICE_REGISTER_CB)(int iUserID, DWORD dwDataType, 
+ *            void* pOutBuffer, DWORD dwOutLen, void* pInBuffer, DWORD dwInLen, void* pUser)
+ * 
+ * iUserID:       用户ID(登录成功后返回)
+ * dwDataType:    数据类型(DEV_REG_TYPE_XXX)
+ * pOutBuffer:    输出缓冲区(设备注册信息)
+ * dwOutLen:      输出缓冲区长度
+ * pInBuffer:     输入缓冲区
+ * dwInLen:       输入缓冲区长度
+ * pUser:         用户自定义参数
+ */
+typedef void (*DEVICE_REGISTER_CB)(int iUserID, int dwDataType, 
+                                   void* pOutBuffer, int dwOutLen, 
+                                   void* pInBuffer, int dwInLen, 
+                                   void* pUser);
+
+/* 设备状态回调 */
+typedef void (*DeviceStatusCB)(const char* device_id, DeviceStatus status, void* user_data);
+
+/**
+ * @brief 初始化CMS库
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ * 
+ * 说明: 必须在使用ISUP SDK任何其他接口之前调用此函数。
+ *       初始化CMS库，分配SDK所需全局资源。
+ */
+int platform_cms_init(void);
+
+/**
+ * @brief 反初始化CMS库
+ * 
+ * 说明: 程序退出前调用，释放CMS库占用的资源。
+ */
+void platform_cms_cleanup(void);
+
+/**
+ * @brief 启动CMS监听(接收设备注册请求)
+ * @param listen_ip 监听IP地址, "0.0.0.0"表示监听所有接口
+ * @param listen_port 监听端口
+ * @param reg_callback 设备注册回调函数
+ * @param user_data 用户自定义数据
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ * 
+ * 说明: 启动后CMS服务器开始监听来自设备的注册请求。
+ *       当设备注册/上线/下线时，会回调reg_callback函数。
+ */
+int platform_cms_start_listen(const char* listen_ip, short listen_port,
+                              DEVICE_REGISTER_CB reg_callback, void* user_data);
+
+/**
+ * @brief 停止CMS监听
+ * 
+ * 说明: 停止接收设备注册请求。
+ */
+void platform_cms_stop_listen(void);
+
+/**
+ * @brief 设备向CMS注册
+ * @param server_ip CMS服务器IP地址
+ * @param server_port CMS服务器端口
+ * @param device_id 设备ID
+ * @param protocol_version 协议版本
+ * @param encrypt_key 加密密钥
+ * @param user_data 用户自定义数据
+ * @return 成功返回用户ID(>=0), 失败返回FAILURE
+ * 
+ * 说明: 设备主动向CMS服务器发起注册请求。
+ *       注册成功后返回用户ID，后续操作使用此ID。
+ */
+int platform_device_register(const char* server_ip, short server_port,
+                             const char* device_id, const char* protocol_version,
+                             const char* encrypt_key, void* user_data);
+
+/**
+ * @brief 设备登出CMS
+ * @param user_id 用户ID
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ */
+int platform_device_logout(int user_id);
+
+/**
+ * @brief 设置自动重连
+ * @param user_id 用户ID
+ * @param enable 是否启用自动重连
+ * @param interval 重连间隔(秒)
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ */
+int platform_set_auto_reconnect(int user_id, int enable, int interval);
+
+/**
+ * @brief 发送心跳包
+ * @param user_id 用户ID
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ */
+int platform_send_heartbeat(int user_id);
+
+/**
+ * @brief 注册设备状态回调
+ * @param cb 状态回调函数
+ * @param user_data 用户自定义数据
+ */
+void platform_register_status_callback(DeviceStatusCB cb, void* user_data);
+
+/**
+ * @brief 获取设备注册信息
+ * @param device_id 设备ID
+ * @param info 输出设备信息结构
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ */
+int platform_get_device_info(const char* device_id, DevRegInfo* info);
+
+/**
+ * @brief 获取所有在线设备列表
+ * @param devices 输出设备ID数组
+ * @param max_devices 最大设备数
+ * @return 返回在线设备数量
+ */
+int platform_get_online_devices(char devices[][MAX_DEVICE_ID], int max_devices);
+
+#endif /* PLATFORM_H */

include/playback.h

@@ -0,0 +1,162 @@
+#ifndef PLAYBACK_H
+#define PLAYBACK_H
+
+/**
+ * @file playback.h
+ * @brief 录像回放管理头文件
+ * 
+ * 本文件定义录像回放相关的功能接口，
+ * 包括回放开始、停止、数据接收等。
+ */
+
+#include "common.h"
+#include "config.h"
+#include "stream.h"
+
+/* 回放状态 */
+typedef enum {
+    PLAYBACK_STATE_IDLE = 0,
+    PLAYBACK_STATE_STARTING,
+    PLAYBACK_STATE_PLAYING,
+    PLAYBACK_STATE_PAUSED,
+    PLAYBACK_STATE_STOPPING,
+    PLAYBACK_STATE_ERROR
+} PlaybackState;
+
+/* 回放会话结构 */
+typedef struct {
+    int      playback_id;         /* 回放ID */
+    char     device_id[MAX_DEVICE_ID]; /* 设备ID */
+    int      channel;             /* 通道号 */
+    PlaybackState state;          /* 回放状态 */
+    
+    time_t   start_time;          /* 回放开始时间 */
+    time_t   end_time;            /* 回放结束时间 */
+    
+    int      speed;               /* 回放速度(1=正常, 2=2倍, 4=4倍...) */
+    int      frame_count;         /* 已接收帧数 */
+    
+    StreamSession* stream;        /* 关联的流会话 */
+    
+    pthread_mutex_t lock;         /* 线程锁 */
+    int      is_running;          /* 是否运行中 */
+    
+    void*    internal_handle;     /* 内部句柄 */
+} PlaybackSession;
+
+/* 回放数据回调 */
+typedef void (*PlaybackDataCB)(PlaybackSession* session, StreamFrame* frame, void* user_data);
+
+/* 回放状态回调 */
+typedef void (*PlaybackStatusCB)(PlaybackSession* session, PlaybackState state, void* user_data);
+
+/**
+ * @brief 初始化回放模块
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ */
+int playback_init(void);
+
+/**
+ * @brief 反初始化回放模块
+ */
+void playback_cleanup(void);
+
+/**
+ * @brief 开始录像回放
+ * @param device_id 设备ID
+ * @param channel 通道号
+ * @param start_time 开始时间
+ * @param end_time 结束时间
+ * @param speed 回放速度
+ * @param data_cb 回放数据回调
+ * @param status_cb 回放状态回调
+ * @param user_data 用户数据
+ * @return 成功返回回放会话指针, 失败返回NULL
+ * 
+ * 说明: 发起录像回放请求。内部流程:
+ *       1. 调用NET_ESTREAM_StartListenPlayBack开启SMS回放监听
+ *       2. 调用NET_ECMS_StartPlayBack向设备发送回放开始请求
+ *       3. 接收设备回放码流数据
+ *       4. 可选: 将回放流转发到RTMP服务器
+ */
+PlaybackSession* playback_start(const char* device_id, int channel,
+                                 time_t start_time, time_t end_time,
+                                 int speed,
+                                 PlaybackDataCB data_cb,
+                                 PlaybackStatusCB status_cb,
+                                 void* user_data);
+
+/**
+ * @brief 停止录像回放
+ * @param session 回放会话指针
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ * 
+ * 说明: 停止回放并释放资源。内部流程:
+ *       1. 调用NET_ESTREAM_StopPlayBack停止码流转发
+ *       2. 调用NET_ECMS_StopPlayBack向设备发送停止请求
+ *       3. 调用NET_ESTREAM_StopListenPlayBack停止监听
+ */
+int playback_stop(PlaybackSession* session);
+
+/**
+ * @brief 暂停回放
+ * @param session 回放会话指针
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ */
+int playback_pause(PlaybackSession* session);
+
+/**
+ * @brief 恢复回放
+ * @param session 回放会话指针
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ */
+int playback_resume(PlaybackSession* session);
+
+/**
+ * @brief 获取录像文件列表
+ * @param device_id 设备ID
+ * @param channel 通道号
+ * @param start_time 开始时间
+ * @param end_time 结束时间
+ * @param files 输出文件列表
+ * @param max_files 最大文件数
+ * @return 返回录像文件数量
+ * 
+ * 说明: 查询指定时间段内的录像文件列表。
+ */
+int playback_get_file_list(const char* device_id, int channel,
+                           time_t start_time, time_t end_time,
+                           char files[][MAX_PATH_SIZE], int max_files);
+
+/**
+ * @brief 下载录像文件
+ * @param device_id 设备ID
+ * @param channel 通道号
+ * @param file_name 文件名
+ * @param save_path 保存路径
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ */
+int playback_download_file(const char* device_id, int channel,
+                           const char* file_name, const char* save_path);
+
+/**
+ * @brief 获取所有活跃回放会话
+ * @param sessions 输出会话指针数组
+ * @param max_sessions 最大会话数
+ * @return 返回活跃会话数量
+ */
+int playback_get_active_sessions(PlaybackSession* sessions[], int max_sessions);
+
+/**
+ * @brief 停止所有回放
+ */
+void playback_stop_all(void);
+
+/**
+ * @brief 获取回放会话状态
+ * @param session 回放会话指针
+ * @return 回放状态枚举值
+ */
+PlaybackState playback_get_state(PlaybackSession* session);
+
+#endif /* PLAYBACK_H */

include/stream.h

@@ -0,0 +1,226 @@
+#ifndef STREAM_H
+#define STREAM_H
+
+/**
+ * @file stream.h
+ * @brief 视频流管理头文件
+ * 
+ * 本文件定义视频流的接收、发送、PS封装、
+ * RTMP推流(zlmediakit)等功能接口。
+ */
+
+#include "common.h"
+#include "config.h"
+
+/* 流状态 */
+typedef enum {
+    STREAM_STATE_IDLE = 0,
+    STREAM_STATE_STARTING,
+    STREAM_STATE_STREAMING,
+    STREAM_STATE_STOPPING,
+    STREAM_STATE_ERROR
+} StreamState;
+
+/* 流类型 */
+typedef enum {
+    STREAM_TYPE_MAIN = 0,         /* 主码流 */
+    STREAM_TYPE_SUB,              /* 子码流 */
+    STREAM_TYPE_THIRD,            /* 第三码流 */
+    STREAM_TYPE_SIM,              /* 模拟流(测试用) */
+} StreamType;
+
+/* 编码类型 */
+typedef enum {
+    CODEC_TYPE_H264 = 0,
+    CODEC_TYPE_H265,
+    CODEC_TYPE_MJPEG,
+    CODEC_TYPE_MPEG4,
+    CODEC_TYPE_UNKNOWN
+} CodecType;
+
+/* 帧信息结构 */
+typedef struct {
+    void*    data;                /* 帧数据指针 */
+    int      data_size;           /* 帧数据大小 */
+    int      timestamp;           /* 时间戳(ms) */
+    int      frame_type;          /* 帧类型(0:I帧, 1:P帧, 2:B帧) */
+    int      codec_type;          /* 编码类型 */
+    int      width;               /* 宽度 */
+    int      height;              /* 高度 */
+    int      is_keyframe;         /* 是否关键帧 */
+    int      is_sps_pps;          /* 是否SPS/PPS */
+} StreamFrame;
+
+/* 流会话结构 */
+typedef struct {
+    int      stream_id;           /* 流ID */
+    char     device_id[MAX_DEVICE_ID]; /* 设备ID */
+    int      channel;             /* 通道号 */
+    StreamType type;              /* 流类型 */
+    StreamState state;            /* 流状态 */
+    CodecType codec;              /* 编码类型 */
+    int      width;               /* 分辨率宽 */
+    int      height;              /* 分辨率高 */
+    int      fps;                 /* 帧率 */
+    int      bitrate;             /* 码率 */
+    pthread_mutex_t lock;         /* 线程锁 */
+    int      is_running;          /* 是否运行中 */
+    void*    internal_handle;     /* 内部句柄 */
+} StreamSession;
+
+/* 流数据回调 */
+typedef void (*StreamDataCB)(StreamSession* session, StreamFrame* frame, void* user_data);
+
+/* RTMP推流回调 */
+typedef void (*RTMPPushCB)(const char* stream_key, int state, void* user_data);
+
+/**
+ * @brief 初始化流媒体库
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ * 
+ * 说明: 初始化SMS(Stream Management Server)库，
+ *       分配流媒体相关的全局资源。
+ */
+int stream_init(void);
+
+/**
+ * @brief 反初始化流媒体库
+ * 
+ * 说明: 释放流媒体相关的所有资源。
+ */
+void stream_cleanup(void);
+
+/**
+ * @brief 开始监听播放回放请求
+ * @param listen_ip 监听IP
+ * @param listen_port 监听端口
+ * @param callback 异常回调函数
+ * @param user_data 用户数据
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ * 
+ * 说明: 开启SMS监听服务，接收来自设备的回放连接请求。
+ *       对应NET_ESTREAM_StartListenPlayBack功能。
+ */
+int stream_start_playback_listen(const char* listen_ip, short listen_port,
+                                  void* callback, void* user_data);
+
+/**
+ * @brief 停止监听播放回放
+ * 
+ * 说明: 停止SMS回放监听服务。
+ *       对应NET_ESTREAM_StopListenPlayBack功能。
+ */
+void stream_stop_playback_listen(void);
+
+/**
+ * @brief 设置回放数据回调
+ * @param stream_handle 流句柄
+ * @param callback 数据回调函数
+ * @param user_data 用户数据
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ * 
+ * 说明: 注册回放数据回调函数，用于接收来自设备的回放码流数据。
+ *       对应NET_ESTREAM_SetPlayBackDataCB功能。
+ */
+int stream_set_playback_data_cb(int stream_handle, StreamDataCB callback, void* user_data);
+
+/**
+ * @brief 创建视频流会话
+ * @param device_id 设备ID
+ * @param channel 通道号
+ * @param stream_type 流类型
+ * @param codec 编码类型
+ * @param width 宽度
+ * @param height 高度
+ * @param fps 帧率
+ * @param bitrate 码率
+ * @return 成功返回流会话指针, 失败返回NULL
+ */
+StreamSession* stream_create_session(const char* device_id, int channel,
+                                      StreamType stream_type, CodecType codec,
+                                      int width, int height, int fps, int bitrate);
+
+/**
+ * @brief 销毁视频流会话
+ * @param session 流会话指针
+ */
+void stream_destroy_session(StreamSession* session);
+
+/**
+ * @brief 开始推流
+ * @param session 流会话指针
+ * @param rtmp_url RTMP推流地址
+ * @param callback 推流状态回调
+ * @param user_data 用户数据
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ * 
+ * 说明: 开始向RTMP服务器推流。内部会将视频帧封装为PS流
+ *       并通过RTMP协议推送到zlmediakit服务器。
+ */
+int stream_start_push(StreamSession* session, const char* rtmp_url,
+                      RTMPPushCB callback, void* user_data);
+
+/**
+ * @brief 停止推流
+ * @param session 流会话指针
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ */
+int stream_stop_push(StreamSession* session);
+
+/**
+ * @brief 发送视频帧到流
+ * @param session 流会话指针
+ * @param frame 视频帧数据
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ * 
+ * 说明: 将视频帧数据发送到RTMP服务器。
+ *       帧数据会被封装为PS(Program Stream)格式后传输。
+ */
+int stream_send_frame(StreamSession* session, StreamFrame* frame);
+
+/**
+ * @brief 停止指定通道的流
+ * @param device_id 设备ID
+ * @param channel 通道号
+ * @return 成功返回SUCCESS, 失败返回FAILURE
+ */
+int stream_stop_channel(const char* device_id, int channel);
+
+/**
+ * @brief 停止所有流
+ */
+void stream_stop_all(void);
+
+/**
+ * @brief 获取流会话状态
+ * @param session 流会话指针
+ * @return 流状态枚举值
+ */
+StreamState stream_get_state(StreamSession* session);
+
+/**
+ * @brief 将原始H.264/H.265数据封装为PS流
+ * @param input_data 原始视频数据
+ * @param input_size 原始数据大小
+ * @param output_buf 输出缓冲区
+ * @param output_size 输出缓冲区大小
+ * @return 封装后的PS数据大小, 失败返回-1
+ * 
+ * 说明: 将H.264/H.264原始码流封装为MPEG-2 Program Stream格式。
+ *       PS流包含系统头、节目复用器头等PS标准结构。
+ */
+int encode_to_ps(const uint8_t* input_data, int input_size,
+                 uint8_t* output_buf, int output_size);
+
+/**
+ * @brief 从PS流中解封装获取H.264/H.265帧
+ * @param ps_data PS流数据
+ * @param ps_size PS流数据大小
+ * @param output_buf 输出缓冲区
+ * @param output_size 输出缓冲区大小
+ * @return 解封装后的帧数据大小, 失败返回-1
+ */
+int decode_ps_to_frame(const uint8_t* ps_data, int ps_size,
+                       uint8_t* output_buf, int output_size);
+
+#endif /* STREAM_H */

scripts/deploy.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+# ============================================================
+# Deployment script for Hikvision ISUP Client
+# ============================================================
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+INSTALL_DIR="/usr/local/bin"
+CONFIG_DIR="/etc/hikvision-isup"
+
+BINARY_NAME="${1:-hikvision-isup-client}"
+
+echo "=== Deploying $BINARY_NAME ==="
+
+# Check if binary exists
+if [ ! -f "$PROJECT_DIR/$BINARY_NAME" ]; then
+    echo "Binary not found: $PROJECT_DIR/$BINARY_NAME"
+    echo "Running make first..."
+    cd "$PROJECT_DIR"
+    make
+fi
+
+# Create config directory
+sudo mkdir -p "$CONFIG_DIR"
+
+# Install binary
+sudo install -m 755 "$PROJECT_DIR/$BINARY_NAME" "$INSTALL_DIR/$BINARY_NAME"
+echo "Binary installed to $INSTALL_DIR/$BINARY_NAME"
+
+# Copy config
+if [ -f "$PROJECT_DIR/config.ini" ]; then
+    sudo cp "$PROJECT_DIR/config.ini" "$CONFIG_DIR/config.ini"
+    echo "Config copied to $CONFIG_DIR/config.ini"
+fi
+
+# Create necessary directories
+sudo mkdir -p /var/log/hikvision-isup
+sudo mkdir -p /var/lib/hikvision-isup/recordings
+sudo mkdir -p /var/lib/hikvision-isup/sim_images
+
+# Create systemd service file
+sudo tee "/etc/systemd/system/hikvision-isup-client.service" > /dev/null << 'EOF'
+[Unit]
+Description=Hikvision ISUP Client - Platform Registration and Stream Management
+After=network.target
+
+[Service]
+Type=simple
+User=root
+WorkingDirectory=/opt/hikvision-isup
+ExecStart=/usr/local/bin/hikvision-isup-client -c /etc/hikvision-isup/config.ini -d
+Restart=on-failure
+RestartSec=5
+StandardOutput=journal
+StandardError=journal
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+echo "Systemd service file created"
+echo ""
+echo "To enable and start the service:"
+echo "  sudo systemctl daemon-reload"
+echo "  sudo systemctl enable hikvision-isup-client"
+echo "  sudo systemctl start hikvision-isup-client"
+echo ""
+echo "To check status:"
+echo "  sudo systemctl status hikvision-isup-client"
+echo "  journalctl -u hikvision-isup-client -f"
+
+echo ""
+echo "=== Deployment complete ==="

scripts/git_sync.sh

@@ -0,0 +1,80 @@
+#!/bin/bash
+# ============================================================
+# Git Auto Sync Script
+# ============================================================
+# This script configures and pushes code to Gogs repository
+# ============================================================
+
+set -e
+
+GOGS_URL="https://git.zhonjin.com:40717/steven_roc"
+REPO_NAME="hikvision-isup-client"
+ACCESS_TOKEN="1942ce3d6478f7a572fee3dd4891e49f6c416aad"
+FULL_URL="${GOGS_URL}/${REPO_NAME}.git"
+
+echo "=== Git Repository Setup ==="
+echo ""
+
+# Check if git is installed
+if ! command -v git &> /dev/null; then
+    echo "Git is not installed. Installing..."
+    sudo apt-get install -y git
+fi
+
+# Initialize git repository if not already initialized
+if [ ! -d ".git" ]; then
+    echo "[1/4] Initializing git repository..."
+    git init
+    git branch -M main
+    echo "Git repository initialized"
+else
+    echo "[1/4] Git repository already exists"
+fi
+
+# Add remote origin with access token
+echo "[2/4] Configuring remote origin..."
+# Remove existing remote if exists
+git remote remove origin 2>/dev/null || true
+# Add remote with credentials in URL
+git remote add origin "https://steven_roc:${ACCESS_TOKEN}@git.zhonjin.com:40717/steven_roc/${REPO_NAME}.git"
+echo "Remote origin added: ${FULL_URL}"
+
+# Configure git user (if not already configured)
+if ! git config user.name &> /dev/null || [ "$(git config user.name)" = "" ]; then
+    git config user.name "steven_roc"
+fi
+if ! git config user.email &> /dev/null || [ "$(git config user.email)" = "" ]; then
+    git config user.email "steven_roc@zhonjin.com"
+fi
+
+# Add all files
+echo "[3/4] Staging files..."
+git add -A
+
+# Check if there are changes to commit
+if git diff --staged --quiet; then
+    echo "No changes to commit"
+else
+    # Commit
+    echo "[4/4] Committing changes..."
+    git commit -m "Initial commit: Hikvision ISUP Client project"
+    echo "Changes committed"
+    
+    # Push to remote
+    echo "Pushing to remote..."
+    git push -u origin main
+    
+    echo ""
+    echo "=== Git setup complete ==="
+    echo "Repository: ${FULL_URL}"
+    echo ""
+    echo "Future sync commands:"
+    echo "  git add -A"
+    echo "  git commit -m 'Your commit message'"
+    echo "  git push"
+else
+    echo "Nothing to push"
+fi
+
+echo ""
+echo "=== Git setup complete ==="

scripts/setup.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+# ============================================================
+# Environment Setup Script
+# ============================================================
+# This script sets up the development environment on Ubuntu 24.04
+# ============================================================
+
+set -e
+
+echo "=== Hikvision ISUP Client - Environment Setup ==="
+echo ""
+
+# Update package list
+echo "[1/6] Updating package list..."
+sudo apt-get update
+
+# Install build dependencies
+echo "[2/6] Installing build dependencies..."
+sudo apt-get install -y \
+    build-essential \
+    gcc \
+    g++ \
+    make \
+    cmake \
+    git \
+    pkg-config \
+    libssl-dev \
+    libpthread-stubs0-dev \
+    valgrind \
+    cppcheck \
+    clang-format
+
+# Install media processing dependencies (for PS encoding/decoding)
+echo "[3/6] Installing media dependencies..."
+sudo apt-get install -y \
+    ffmpeg \
+    libavcodec-dev \
+    libavformat-dev \
+    libavutil-dev \
+    libswscale-dev \
+    libpostproc-dev
+
+# Create project directories
+echo "[4/6] Creating project directories..."
+mkdir -p logs recordings sim_images docs
+
+# Create log directory
+sudo mkdir -p /var/log/hikvision-isup
+
+# Install ZLMediaKit (optional, for RTMP pushing)
+echo "[5/6] Checking ZLMediaKit..."
+if command -v MediaServer &> /dev/null; then
+    echo "ZLMediaKit is already installed"
+else
+    echo "ZLMediaKit not found. To install:"
+    echo "  git clone --depth 1 https://gitee.com/xia-chu/ZLMediaKit"
+    echo "  cd ZLMediaKit && git submodule update --init"
+    echo "  mkdir build && cd build && cmake .. && make -j4"
+    echo "  sudo make install"
+fi
+
+# Check HCNetSDK
+echo "[6/6] Checking HCNetSDK..."
+if [ -d "libs" ]; then
+    echo "libs directory exists"
+    ls -la libs/ || true
+else
+    echo "libs directory not found. Please copy HCNetSDK files to libs/ directory:"
+    echo "  From Hikvision SDK package:"
+    echo "  - CH-HCNetSDKV6.x.x.x buildxxxxxx linux64/"
+    echo "  Copy .so files and .h files to ./libs/"
+fi
+
+echo ""
+echo "=== Setup complete ==="
+echo ""
+echo "Next steps:"
+echo "  1. Copy HCNetSDK library files to ./libs/"
+echo "  2. Edit config.ini with your server settings"
+echo "  3. Run 'make simulate' to build without SDK (for development)"
+echo "  4. Run 'make' to build with SDK"
+echo "  5. Run './hikvision-isup-client -c config.ini' to start"

src/alarm.c

@@ -0,0 +1,243 @@
+#include "alarm.h"
+#include <pthread.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+/* ============================================================
+ * 内部数据结构
+ * ============================================================ */
+
+#define MAX_UNACK_ALARMS 1024
+
+static int g_alarm_listen_socket = -1;
+static pthread_t g_alarm_listen_thread;
+static int g_alarm_stop = 0;
+
+static AlarmDataCB g_alarm_cb = NULL;
+static void* g_alarm_user_data = NULL;
+
+static AlarmProcessCB g_process_cb = NULL;
+static void* g_process_user_data = NULL;
+
+static AlarmInfo g_unack_alarms[MAX_UNACK_ALARMS];
+static int g_unack_count = 0;
+
+static int g_total_alarms = 0;
+static int g_today_alarms = 0;
+
+static pthread_mutex_t g_alarm_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/* ============================================================
+ * 内部函数
+ * ============================================================ */
+
+static int add_unack_alarm(AlarmInfo* alarm) {
+    pthread_mutex_lock(&g_alarm_mutex);
+    
+    if (g_unack_count >= MAX_UNACK_ALARMS) {
+        pthread_mutex_unlock(&g_alarm_mutex);
+        LOG_WARN("Unacknowledged alarm queue full, dropping alarm");
+        return FAILURE;
+    }
+    
+    memcpy(&g_unack_alarms[g_unack_count], alarm, sizeof(AlarmInfo));
+    g_unack_alarms[g_unack_count].is_acknowledged = 0;
+    g_unack_count++;
+    g_total_alarms++;
+    g_today_alarms++;
+    
+    pthread_mutex_unlock(&g_alarm_mutex);
+    LOG_WARN("New alarm registered: Type=%d, Device=%s, Channel=%d, Description=%s",
+             alarm->type, alarm->device_id, alarm->channel, alarm->description);
+    
+    return SUCCESS;
+}
+
+/* 报警监听线程函数 */
+static void* alarm_listen_thread_func(void* arg) {
+    (void)arg;
+    
+    LOG_INFO("Alarm listen thread started");
+    
+    while (!g_alarm_stop) {
+        /* 在实际实现中，这里会阻塞接收来自设备的报警数据
+         * 使用HCNetSDK的报警监听功能:
+         * 
+         * struct sockaddr_in addr;
+         * socklen_t addr_len = sizeof(addr);
+         * int client_fd = accept(g_alarm_listen_socket, (struct sockaddr*)&addr, &addr_len);
+         * 
+         * char buf[MAX_BUF_SIZE];
+         * int bytes = recv(client_fd, buf, sizeof(buf), 0);
+         * 
+         * 解析报警数据并触发回调
+         */
+        
+        /* 模拟实现: 休眠并检查停止标志 */
+        sleep_milliseconds(500);
+        
+        /* 在实际实现中，这里会处理接收到的报警数据 */
+    }
+    
+    LOG_INFO("Alarm listen thread stopped");
+    return NULL;
+}
+
+/* ============================================================
+ * 公共接口实现
+ * ============================================================ */
+
+int alarm_init(void) {
+    LOG_INFO("Initializing alarm module...");
+    
+    /* 初始化报警库 */
+    if (NET_EALARM_Init() != SUCCESS) {
+        LOG_ERROR("Failed to initialize alarm library");
+        return FAILURE;
+    }
+    
+    g_unack_count = 0;
+    g_total_alarms = 0;
+    g_today_alarms = 0;
+    g_alarm_stop = 0;
+    
+    LOG_INFO("Alarm module initialized");
+    return SUCCESS;
+}
+
+void alarm_cleanup(void) {
+    LOG_INFO("Cleaning up alarm module...");
+    
+    g_alarm_stop = 1;
+    
+    if (g_alarm_listen_socket >= 0) {
+        close(g_alarm_listen_socket);
+        g_alarm_listen_socket = -1;
+    }
+    
+    if (g_alarm_listen_thread != 0) {
+        pthread_join(g_alarm_listen_thread, NULL);
+        g_alarm_listen_thread = 0;
+    }
+    
+    NET_EALARM_Clean();
+    
+    LOG_INFO("Alarm module cleaned up");
+}
+
+int alarm_start_listen(const char* listen_ip, short listen_port,
+                       AlarmDataCB alarm_cb, AlarmProcessCB process_cb,
+                       void* user_data) {
+    if (listen_ip == NULL || alarm_cb == NULL) {
+        LOG_ERROR("Invalid parameters");
+        return FAILURE;
+    }
+    
+    g_alarm_cb = alarm_cb;
+    g_alarm_user_data = user_data;
+    g_process_cb = process_cb;
+    g_process_user_data = user_data;
+    
+    LOG_INFO("Starting alarm listen on %s:%d...", listen_ip, listen_port);
+    
+    /* 调用HCNetSDK启动报警监听
+     * 对应NET_EALARM_StartListen接口
+     */
+    if (NET_EALARM_StartListen((char*)listen_ip, listen_port, NULL, NULL) != SUCCESS) {
+        LOG_ERROR("Failed to start alarm listen");
+        return FAILURE;
+    }
+    
+    /* 启动监听线程 */
+    g_alarm_stop = 0;
+    if (pthread_create(&g_alarm_listen_thread, NULL, alarm_listen_thread_func, NULL) != 0) {
+        LOG_ERROR("Failed to create alarm listen thread");
+        return FAILURE;
+    }
+    
+    LOG_INFO("Alarm listen started successfully");
+    return SUCCESS;
+}
+
+void alarm_stop_listen(void) {
+    LOG_INFO("Stopping alarm listen...");
+    g_alarm_stop = 1;
+    
+    if (g_alarm_listen_socket >= 0) {
+        close(g_alarm_listen_socket);
+        g_alarm_listen_socket = -1;
+    }
+    
+    LOG_INFO("Alarm listen stopped");
+}
+
+int alarm_acknowledge(int alarm_id, const char* device_id) {
+    (void)alarm_id;
+    (void)device_id;
+    
+    LOG_INFO("Alarm acknowledged: ID=%d, Device=%s", alarm_id, device_id);
+    
+    /* 在实际实现中，标记报警为已确认并从队列中移除 */
+    
+    return SUCCESS;
+}
+
+int alarm_get_unacknowledged(AlarmInfo alarms[], int max_alarms) {
+    int count = 0;
+    pthread_mutex_lock(&g_alarm_mutex);
+    
+    for (int i = 0; i < g_unack_count && count < max_alarms; i++) {
+        if (!g_unack_alarms[i].is_acknowledged) {
+            memcpy(&alarms[count], &g_unack_alarms[i], sizeof(AlarmInfo));
+            count++;
+        }
+    }
+    
+    pthread_mutex_unlock(&g_alarm_mutex);
+    return count;
+}
+
+int alarm_clear_acknowledged(void) {
+    pthread_mutex_lock(&g_alarm_mutex);
+    
+    int removed = 0;
+    int write_idx = 0;
+    
+    for (int read_idx = 0; read_idx < g_unack_count; read_idx++) {
+        if (!g_unack_alarms[read_idx].is_acknowledged) {
+            g_unack_alarms[write_idx++] = g_unack_alarms[read_idx];
+        } else {
+            removed++;
+        }
+    }
+    
+    g_unack_count = write_idx;
+    
+    pthread_mutex_unlock(&g_alarm_mutex);
+    LOG_INFO("Cleared %d acknowledged alarms", removed);
+    return SUCCESS;
+}
+
+void alarm_register_filter(const AlarmType types[], int count) {
+    LOG_INFO("Registering alarm filter: %d types", count);
+    /* 在实际实现中，设置服务器端报警类型过滤器 */
+    (void)types;
+    (void)count;
+}
+
+void alarm_get_stats(int* total, int* unack, int* today) {
+    pthread_mutex_lock(&g_alarm_mutex);
+    
+    if (total) *total = g_total_alarms;
+    if (unack) {
+        int u = 0;
+        for (int i = 0; i < g_unack_count; i++) {
+            if (!g_unack_alarms[i].is_acknowledged) u++;
+        }
+        *unack = u;
+    }
+    if (today) *today = g_today_alarms;
+    
+    pthread_mutex_unlock(&g_alarm_mutex);
+}

src/config.c

@@ -0,0 +1,197 @@
+#include "config.h"
+#include <stdio.h>
+#include <ctype.h>
+
+void config_init_default(AppConfig* config) {
+    if (config == NULL) return;
+    
+    memset(config, 0, sizeof(AppConfig));
+    
+    /* CMS配置 - 与图片中的设备配置对应 */
+    safe_strcpy(config->cms.server_ip, "117.131.63.98", MAX_IP_SIZE);
+    config->cms.server_port = 7031;
+    safe_strcpy(config->cms.device_id, "AX5324540", MAX_DEVICE_ID);
+    safe_strcpy(config->cms.protocol_version, "ISUP5.0", sizeof(config->cms.protocol_version));
+    safe_strcpy(config->cms.encrypt_key, "abc12345", sizeof(config->cms.encrypt_key));
+    config->cms.enable = 1;
+    config->cms.auto_reconnect = 1;
+    config->cms.reconnect_interval = REG_RETRY_INTERVAL;
+    
+    /* SMS配置 */
+    safe_strcpy(config->sms.listen_ip, "0.0.0.0", MAX_IP_SIZE);
+    config->sms.listen_port = DEFAULT_SMS_PORT;
+    config->sms.max_streams = MAX_STREAM_NUM;
+    config->sms.stream_timeout = STREAM_TIMEOUT;
+    
+    /* 报警配置 */
+    safe_strcpy(config->alarm.listen_ip, "0.0.0.0", MAX_IP_SIZE);
+    config->alarm.listen_port = DEFAULT_ALARM_PORT;
+    config->alarm.enable = 1;
+    
+    /* RTMP配置 */
+    safe_strcpy(config->rtmp.rtmp_server, "127.0.0.1", MAX_IP_SIZE);
+    config->rtmp.rtmp_port = DEFAULT_RTMP_PORT;
+    safe_strcpy(config->rtmp.app_name, "live", sizeof(config->rtmp.app_name));
+    safe_strcpy(config->rtmp.stream_key, "camera1", sizeof(config->rtmp.stream_key));
+    config->rtmp.enable = 1;
+    config->rtmp.auto_start = 1;
+    config->rtmp.reconnect = 1;
+    config->rtmp.reconnect_interval = 5;
+    
+    /* 回放配置 */
+    config->playback.enable = 1;
+    config->playback.max_concurrent = MAX_PLAYBACK_NUM;
+    safe_strcpy(config->playback.save_path, "./recordings", MAX_PATH_SIZE);
+    config->playback.record_duration = 3600;
+    
+    /* 模拟配置 */
+    config->sim.enable = 1;
+    safe_strcpy(config->sim.image_dir, "./sim_images", MAX_PATH_SIZE);
+    config->sim.width = SIM_IMAGE_WIDTH;
+    config->sim.height = SIM_IMAGE_HEIGHT;
+    config->sim.fps = SIM_FPS;
+    config->sim.bitrate = SIM_BITRATE;
+    config->sim.gop_size = SIM_FPS * 2;  /* 2秒GOP */
+    config->sim.test_image_count = 100;
+    
+    /* 通用配置 */
+    safe_strcpy(config->log_file, "./logs/isup_client.log", MAX_PATH_SIZE);
+    config->log_level = LOG_LEVEL_INFO;
+    config->daemon_mode = 0;
+}
+
+int config_load(AppConfig* config, const char* config_file) {
+    if (config == NULL || config_file == NULL) {
+        LOG_ERROR("Invalid parameters");
+        return FAILURE;
+    }
+    
+    /* 先加载默认配置 */
+    config_init_default(config);
+    
+    /* 从文件覆盖配置 */
+    char* val;
+    
+    val = read_config_value(config_file, "cms_server_ip");
+    if (val) safe_strcpy(config->cms.server_ip, val, MAX_IP_SIZE);
+    
+    val = read_config_value(config_file, "cms_server_port");
+    if (val) config->cms.server_port = atoi(val);
+    
+    val = read_config_value(config_file, "device_id");
+    if (val) safe_strcpy(config->cms.device_id, val, MAX_DEVICE_ID);
+    
+    val = read_config_value(config_file, "protocol_version");
+    if (val) safe_strcpy(config->cms.protocol_version, val, sizeof(config->cms.protocol_version));
+    
+    val = read_config_value(config_file, "encrypt_key");
+    if (val) safe_strcpy(config->cms.encrypt_key, val, sizeof(config->cms.encrypt_key));
+    
+    val = read_config_value(config_file, "sms_listen_port");
+    if (val) config->sms.listen_port = atoi(val);
+    
+    val = read_config_value(config_file, "rtmp_server");
+    if (val) safe_strcpy(config->rtmp.rtmp_server, val, MAX_IP_SIZE);
+    
+    val = read_config_value(config_file, "rtmp_port");
+    if (val) config->rtmp.rtmp_port = atoi(val);
+    
+    val = read_config_value(config_file, "log_level");
+    if (val) config->log_level = atoi(val);
+    
+    LOG_INFO("Configuration loaded from: %s", config_file);
+    return SUCCESS;
+}
+
+int config_save(const AppConfig* config, const char* config_file) {
+    if (config == NULL || config_file == NULL) {
+        LOG_ERROR("Invalid parameters");
+        return FAILURE;
+    }
+    
+    FILE* fp = fopen(config_file, "w");
+    if (fp == NULL) {
+        LOG_ERROR("Failed to open config file for writing: %s", config_file);
+        return FAILURE;
+    }
+    
+    fprintf(fp, "# ISUP Client Configuration File\n");
+    fprintf(fp, "# Format: key=value\n\n");
+    
+    fprintf(fp, "[CMS]\n");
+    fprintf(fp, "cms_server_ip=%s\n", config->cms.server_ip);
+    fprintf(fp, "cms_server_port=%d\n", config->cms.server_port);
+    fprintf(fp, "device_id=%s\n", config->cms.device_id);
+    fprintf(fp, "protocol_version=%s\n", config->cms.protocol_version);
+    fprintf(fp, "encrypt_key=%s\n", config->cms.encrypt_key);
+    fprintf(fp, "enable=%d\n", config->cms.enable);
+    fprintf(fp, "auto_reconnect=%d\n", config->cms.auto_reconnect);
+    fprintf(fp, "reconnect_interval=%d\n\n", config->cms.reconnect_interval);
+    
+    fprintf(fp, "[SMS]\n");
+    fprintf(fp, "listen_ip=%s\n", config->sms.listen_ip);
+    fprintf(fp, "listen_port=%d\n", config->sms.listen_port);
+    fprintf(fp, "max_streams=%d\n", config->sms.max_streams);
+    fprintf(fp, "stream_timeout=%d\n\n", config->sms.stream_timeout);
+    
+    fprintf(fp, "[Alarm]\n");
+    fprintf(fp, "listen_ip=%s\n", config->alarm.listen_ip);
+    fprintf(fp, "listen_port=%d\n", config->alarm.listen_port);
+    fprintf(fp, "enable=%d\n\n", config->alarm.enable);
+    
+    fprintf(fp, "[RTMP]\n");
+    fprintf(fp, "rtmp_server=%s\n", config->rtmp.rtmp_server);
+    fprintf(fp, "rtmp_port=%d\n", config->rtmp.rtmp_port);
+    fprintf(fp, "app_name=%s\n", config->rtmp.app_name);
+    fprintf(fp, "stream_key=%s\n", config->rtmp.stream_key);
+    fprintf(fp, "enable=%d\n", config->rtmp.enable);
+    fprintf(fp, "auto_start=%d\n", config->rtmp.auto_start);
+    fprintf(fp, "reconnect=%d\n", config->rtmp.reconnect);
+    fprintf(fp, "reconnect_interval=%d\n\n", config->rtmp.reconnect_interval);
+    
+    fprintf(fp, "[Playback]\n");
+    fprintf(fp, "enable=%d\n", config->playback.enable);
+    fprintf(fp, "max_concurrent=%d\n", config->playback.max_concurrent);
+    fprintf(fp, "save_path=%s\n", config->playback.save_path);
+    fprintf(fp, "record_duration=%d\n\n", config->playback.record_duration);
+    
+    fprintf(fp, "[Sim]\n");
+    fprintf(fp, "enable=%d\n", config->sim.enable);
+    fprintf(fp, "image_dir=%s\n", config->sim.image_dir);
+    fprintf(fp, "width=%d\n", config->sim.width);
+    fprintf(fp, "height=%d\n", config->sim.height);
+    fprintf(fp, "fps=%d\n", config->sim.fps);
+    fprintf(fp, "bitrate=%d\n", config->sim.bitrate);
+    fprintf(fp, "gop_size=%d\n", config->sim.gop_size);
+    fprintf(fp, "test_image_count=%d\n", config->sim.test_image_count);
+    
+    fprintf(fp, "[General]\n");
+    fprintf(fp, "log_file=%s\n", config->log_file);
+    fprintf(fp, "log_level=%d\n", config->log_level);
+    fprintf(fp, "daemon_mode=%d\n", config->daemon_mode);
+    
+    fclose(fp);
+    LOG_INFO("Configuration saved to: %s", config_file);
+    return SUCCESS;
+}
+
+void config_print(const AppConfig* config) {
+    if (config == NULL) return;
+    
+    LOG_INFO("=== ISUP Client Configuration ===");
+    LOG_INFO("[CMS] Server: %s:%d, DeviceID: %s, Version: %s",
+             config->cms.server_ip, config->cms.server_port,
+             config->cms.device_id, config->cms.protocol_version);
+    LOG_INFO("[SMS] Listen: %s:%d, MaxStreams: %d",
+             config->sms.listen_ip, config->sms.listen_port, config->sms.max_streams);
+    LOG_INFO("[Alarm] Listen: %s:%d, Enable: %d",
+             config->alarm.listen_ip, config->alarm.listen_port, config->alarm.enable);
+    LOG_INFO("[RTMP] Server: %s:%d, App: %s, Stream: %s",
+             config->rtmp.rtmp_server, config->rtmp.rtmp_port,
+             config->rtmp.app_name, config->rtmp.stream_key);
+    LOG_INFO("[Playback] Enable: %d, MaxConcurrent: %d",
+             config->playback.enable, config->playback.max_concurrent);
+    LOG_INFO("[Sim] Enable: %d, Resolution: %dx%d, FPS: %d",
+             config->sim.enable, config->sim.width, config->sim.height, config->sim.fps);
+    LOG_INFO("=================================");
+}

src/main.c

@@ -0,0 +1,469 @@
+#include "common.h"
+#include "config.h"
+#include "platform.h"
+#include "stream.h"
+#include "playback.h"
+#include "alarm.h"
+#include <signal.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+/* ============================================================
+ * 全局变量
+ * ============================================================ */
+static AppConfig g_config;
+static int g_running = 1;
+
+/* ============================================================
+ * 回调函数实现
+ * ============================================================ */
+
+/**
+ * @brief 设备注册回调
+ * 
+ * 当设备注册/上线/下线时，CMS服务器会调用此回调函数。
+ * 
+ * 参数说明:
+ * iUserID:       用户ID(登录成功后返回的ID)
+ * dwDataType:    数据类型
+ *                - DEV_REG_TYPE_ON: 设备上线
+ *                - DEV_REG_TYPE_OFF: 设备下线
+ *                - DEV_REG_TYPE_AUTH: 设备认证
+ *                - DEV_REG_TYPE_SESSIONKEY: 会话密钥
+ *                - DEV_REG_TYPE_ADDRESS_CHANGED: 地址变更
+ * pOutBuffer:    输出缓冲区(包含设备注册信息)
+ * dwOutLen:      输出缓冲区长度
+ * pInBuffer:     输入缓冲区
+ * dwInLen:       输入缓冲区长度
+ * pUser:         用户自定义数据
+ */
+static void device_register_callback(int iUserID, int dwDataType,
+                                     void* pOutBuffer, int dwOutLen,
+                                     void* pInBuffer, int dwInLen,
+                                     void* pUser) {
+    (void)pOutBuffer; (void)dwOutLen; (void)pInBuffer; (void)dwInLen; (void)pUser;
+    
+    char timebuf[64];
+    get_timestamp(timebuf, sizeof(timebuf), NULL);
+    
+    switch (dwDataType) {
+    case DEV_REG_TYPE_ON:
+        LOG_INFO("[%s] Device ONLINE: UserID=%d", timebuf, iUserID);
+        LOG_INFO("  -> Device registered successfully, can now receive streams");
+        
+        /* 设备上线后自动开始推流(如果配置了自动推流) */
+        if (g_config.rtmp.auto_start && g_config.rtmp.enable) {
+            LOG_INFO("  -> Auto starting RTMP push...");
+            /* 这里可以创建流会话并开始推流 */
+        }
+        break;
+        
+    case DEV_REG_TYPE_OFF:
+        LOG_INFO("[%s] Device OFFLINE: UserID=%d", timebuf, iUserID);
+        /* 设备下线，停止相关流 */
+        stream_stop_all();
+        break;
+        
+    case DEV_REG_TYPE_AUTH:
+        LOG_INFO("[%s] Device AUTH: UserID=%d", timebuf, iUserID);
+        break;
+        
+    case DEV_REG_TYPE_SESSIONKEY:
+        LOG_INFO("[%s] Session Key: UserID=%d", timebuf, iUserID);
+        break;
+        
+    case DEV_REG_TYPE_ADDRESS_CHANGED:
+        LOG_INFO("[%s] Address Changed: UserID=%d", timebuf, iUserID);
+        break;
+        
+    case DEV_REG_TYPE_HEARTBEAT:
+        LOG_INFO("[%s] Heartbeat: UserID=%d", timebuf, iUserID);
+        break;
+        
+    default:
+        LOG_INFO("[%s] Unknown event type: %d, UserID=%d", timebuf, dwDataType, iUserID);
+        break;
+    }
+}
+
+/**
+ * @brief 设备状态回调
+ */
+static void device_status_callback(const char* device_id, DeviceStatus status, void* user_data) {
+    (void)user_data;
+    
+    char timebuf[64];
+    get_timestamp(timebuf, sizeof(timebuf), NULL);
+    
+    const char* status_str = "UNKNOWN";
+    switch (status) {
+    case DEVICE_STATUS_OFFLINE: status_str = "OFFLINE"; break;
+    case DEVICE_STATUS_ONLINE: status_str = "ONLINE"; break;
+    case DEVICE_STATUS_REGISTERS: status_str = "REGISTERING"; break;
+    case DEVICE_STATUS_STREAMING: status_str = "STREAMING"; break;
+    case DEVICE_STATUS_PLAYBACK: status_str = "PLAYBACK"; break;
+    }
+    
+    LOG_INFO("[%s] Device status changed: %s -> %s", timebuf, device_id, status_str);
+}
+
+/**
+ * @brief 报警数据回调
+ */
+static void alarm_data_callback(AlarmInfo* alarm, void* user_data) {
+    (void)user_data;
+    
+    if (alarm == NULL) return;
+    
+    char timebuf[64];
+    get_timestamp(timebuf, sizeof(timebuf), NULL);
+    
+    const char* type_str = "UNKNOWN";
+    switch (alarm->type) {
+    case ALARM_TYPE_MOVEMENT: type_str = "MOVEMENT_DETECTION"; break;
+    case ALARM_TYPE_VI_DETECTION: type_str = "VIDEO_LOST"; break;
+    case ALARM_TYPE_VI_MASK: type_str = "VIDEO_MASK"; break;
+    case ALARM_TYPE_NETWORK_ABNORMAL: type_str = "NETWORK_ABNORMAL"; break;
+    case ALARM_TYPE_DISK_ERROR: type_str = "DISK_ERROR"; break;
+    case ALARM_TYPE_IP_CONFLICT: type_str = "IP_CONFLICT"; break;
+    case ALARM_TYPE_STORAGE_EXCEPTION: type_str = "STORAGE_EXCEPTION"; break;
+    case ALARM_TYPE_IO_EXCEPTION: type_str = "IO_EXCEPTION"; break;
+    case ALARM_TYPE_SIZE_OVERFLOW: type_str = "SIZE_OVERFLOW"; break;
+    case ALARM_TYPE_DARKNESS: type_str = "DARKNESS"; break;
+    case ALARM_TYPE_LINE_DETECTION: type_str = "LINE_DETECTION"; break;
+    case ALARM_TYPE_AREA_DETECTION: type_str = "AREA_DETECTION"; break;
+    case ALARM_TYPE_TAMPERING: type_str = "TAMPERING"; break;
+    case ALARM_TYPE_AUDIO_EXCEPTION: type_str = "AUDIO_EXCEPTION"; break;
+    case ALARM_TYPE_THERMAL: type_str = "THERMAL"; break;
+    default: type_str = "CUSTOM"; break;
+    }
+    
+    LOG_WARN("[%s] ALARM: Type=%s, Device=%s, Channel=%d, Level=%d, Desc=%s",
+             timebuf, type_str, alarm->device_id, alarm->channel,
+             alarm->level, alarm->description);
+    
+    /* 将报警信息添加到未确认队列 */
+    alarm_acknowledge(alarm->alarm_id, alarm->device_id);
+}
+
+/**
+ * @brief 报警处理回调(在业务线程中调用)
+ */
+static void alarm_process_callback(AlarmInfo* alarm, void* user_data) {
+    (void)user_data;
+    
+    if (alarm == NULL) return;
+    
+    char timebuf[64];
+    get_timestamp(timebuf, sizeof(timebuf), NULL);
+    
+    LOG_INFO("[%s] Alarm processed: Device=%s, Type=%d, Desc=%s",
+             timebuf, alarm->device_id, alarm->type, alarm->description);
+    
+    /* 这里可以执行业务逻辑:
+     * 1. 保存报警快照到数据库
+     * 2. 发送通知(邮件/短信/飞书等)
+     * 3. 触发联动设备(如打开灯光、录像等)
+     * 4. 写入日志系统
+     */
+}
+
+/**
+ * @brief 信号处理函数
+ */
+static void signal_handler(int sig) {
+    char timebuf[64];
+    get_timestamp(timebuf, sizeof(timebuf), NULL);
+    
+    const char* sig_name = "UNKNOWN";
+    switch (sig) {
+    case SIGINT: sig_name = "SIGINT"; break;
+    case SIGTERM: sig_name = "SIGTERM"; break;
+    case SIGSEGV: sig_name = "SIGSEGV"; break;
+    case SIGABRT: sig_name = "SIGABRT"; break;
+    }
+    
+    LOG_WARN("[%s] Received signal: %s, shutting down...", timebuf, sig_name);
+    g_running = 0;
+}
+
+/**
+ * @brief 模拟图片生成(用于测试)
+ * 
+ * 在实际部署中，视频流来自海康设备。
+ * 在开发测试阶段，可以使用本函数生成模拟视频帧。
+ */
+static void* sim_image_thread_func(void* arg) {
+    (void)arg;
+    
+    LOG_INFO("Simulated image thread started");
+    
+    int frame_count = 0;
+    while (g_running) {
+        /* 在实际实现中，这里会:
+         * 1. 从图片目录读取测试图片
+         * 2. 使用FFmpeg/libswscale将图片编码为H.264帧
+         * 3. 将帧封装为PS流
+         * 4. 通过流会话发送
+         */
+        
+        frame_count++;
+        
+        if (frame_count % 100 == 0) {
+            char timebuf[64];
+            get_timestamp(timebuf, sizeof(timebuf), NULL);
+            LOG_INFO("[%s] Simulated frames generated: %d", timebuf, frame_count);
+        }
+        
+        /* 按照配置的帧率发送 */
+        int sleep_ms = 1000 / g_config.sim.fps;
+        sleep_milliseconds(sleep_ms);
+    }
+    
+    LOG_INFO("Simulated image thread stopped (total frames: %d)", frame_count);
+    return NULL;
+}
+
+/**
+ * @brief 心跳保活线程
+ */
+static void* heartbeat_thread_func(void* arg) {
+    (void)arg;
+    
+    LOG_INFO("Heartbeat thread started");
+    
+    while (g_running) {
+        sleep_milliseconds(HEARTBEAT_INTERVAL * 1000);
+        
+        if (g_running) {
+            /* 发送心跳包保持设备在线 */
+            /* 在实际实现中，遍历所有已注册设备发送心跳 */
+        }
+    }
+    
+    LOG_INFO("Heartbeat thread stopped");
+    return NULL;
+}
+
+/**
+ * @brief 打印使用说明
+ */
+static void print_usage(const char* progname) {
+    printf("Usage: %s [options]\n", progname);
+    printf("Options:\n");
+    printf("  -c <file>   Configuration file path (default: ./config.ini)\n");
+    printf("  -d          Run as daemon\n");
+    printf("  -h          Show this help\n");
+    printf("  -v          Show version\n");
+    printf("  -test       Run self-test mode\n");
+    printf("\n");
+    printf("Version: %s %s\n", PROJECT_NAME, PROJECT_VERSION);
+    printf("Build: %s\n", PROJECT_BUILD_DATE);
+}
+
+/**
+ * @brief 打印版本信息
+ */
+static void print_version(void) {
+    printf("%s v%s\n", PROJECT_NAME, PROJECT_VERSION);
+    printf("Build date: %s\n", PROJECT_BUILD_DATE);
+    printf("Target: Linux %s\n", "x86_64");
+}
+
+/* ============================================================
+ * 主函数
+ * ============================================================ */
+int main(int argc, char* argv[]) {
+    char timebuf[64];
+    get_timestamp(timebuf, sizeof(timebuf), NULL);
+    
+    printf("==================================================\n");
+    printf("  %s v%s\n", PROJECT_NAME, PROJECT_VERSION);
+    printf("  Build: %s\n", PROJECT_BUILD_DATE);
+    printf("  Started: %s\n", timebuf);
+    printf("==================================================\n");
+    
+    /* 命令行参数解析 */
+    const char* config_file = "./config.ini";
+    int daemon_mode = 0;
+    int test_mode = 0;
+    
+    for (int i = 1; i < argc; i++) {
+        if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) {
+            print_usage(argv[0]);
+            return 0;
+        } else if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--version") == 0) {
+            print_version();
+            return 0;
+        } else if (strcmp(argv[i], "-c") == 0 && i + 1 < argc) {
+            config_file = argv[++i];
+        } else if (strcmp(argv[i], "-d") == 0) {
+            daemon_mode = 1;
+        } else if (strcmp(argv[i], "-test") == 0) {
+            test_mode = 1;
+        } else {
+            printf("Unknown option: %s\n", argv[i]);
+            print_usage(argv[0]);
+            return 1;
+        }
+    }
+    
+    /* 初始化配置 */
+    config_init_default(&g_config);
+    g_config.daemon_mode = daemon_mode;
+    
+    /* 加载配置文件 */
+    if (config_load(&g_config, config_file) != SUCCESS) {
+        LOG_WARN("Failed to load config file: %s, using defaults", config_file);
+    }
+    
+    /* 打印配置 */
+    config_print(&g_config);
+    
+    /* 创建必要目录 */
+    ensure_directory("./logs");
+    ensure_directory("./sim_images");
+    ensure_directory(g_config.playback.save_path);
+    
+    /* 注册信号处理 */
+    signal(SIGINT, signal_handler);
+    signal(SIGTERM, signal_handler);
+    signal(SIGSEGV, signal_handler);
+    signal(SIGABRT, signal_handler);
+    
+    /* 守护进程模式 */
+    if (daemon_mode) {
+        if (daemon(1, 1) != 0) {
+            LOG_ERROR("Failed to start as daemon: %s", strerror(errno));
+            return 1;
+        }
+        LOG_INFO("Started as daemon");
+    }
+    
+    /* 写入PID文件 */
+    char pid_path[MAX_PATH_SIZE];
+    snprintf(pid_path, sizeof(pid_path), "./logs/%s.pid", PROJECT_NAME);
+    FILE* pid_fp = fopen(pid_path, "w");
+    if (pid_fp) {
+        fprintf(pid_fp, "%d", getpid());
+        fclose(pid_fp);
+    }
+    
+    /* ===== 初始化各模块 ===== */
+    
+    /* 1. 初始化平台注册模块(CMS) */
+    if (platform_cms_init() != SUCCESS) {
+        LOG_ERROR("Failed to initialize platform module");
+        goto cleanup;
+    }
+    
+    /* 2. 初始化流媒体模块 */
+    if (stream_init() != SUCCESS) {
+        LOG_ERROR("Failed to initialize stream module");
+        goto cleanup_platform;
+    }
+    
+    /* 3. 初始化回放模块 */
+    if (playback_init() != SUCCESS) {
+        LOG_ERROR("Failed to initialize playback module");
+        goto cleanup_stream;
+    }
+    
+    /* 4. 初始化报警模块 */
+    if (alarm_init() != SUCCESS) {
+        LOG_ERROR("Failed to initialize alarm module");
+        goto cleanup_playback;
+    }
+    
+    /* ===== 启动各服务 ===== */
+    
+    /* 1. 启动CMS监听(接收设备注册) */
+    if (g_config.cms.enable) {
+        if (platform_cms_start_listen("0.0.0.0", g_config.cms.server_port,
+                                      device_register_callback, NULL) != SUCCESS) {
+            LOG_ERROR("Failed to start CMS listen");
+        } else {
+            LOG_INFO("CMS listen started on port %d", g_config.cms.server_port);
+        }
+    }
+    
+    /* 2. 注册设备状态回调 */
+    platform_register_status_callback(device_status_callback, NULL);
+    
+    /* 3. 启动报警监听 */
+    if (g_config.alarm.enable) {
+        if (alarm_start_listen("0.0.0.0", g_config.alarm.listen_port,
+                               alarm_data_callback, alarm_process_callback, NULL) != SUCCESS) {
+            LOG_WARN("Failed to start alarm listen");
+        } else {
+            LOG_INFO("Alarm listen started on port %d", g_config.alarm.listen_port);
+        }
+    }
+    
+    /* 4. 启动心跳保活线程 */
+    pthread_t heartbeat_thread;
+    if (pthread_create(&heartbeat_thread, NULL, heartbeat_thread_func, NULL) != 0) {
+        LOG_WARN("Failed to create heartbeat thread");
+    }
+    
+    /* 5. 模拟模式: 启动模拟图片生成线程 */
+    if (g_config.sim.enable) {
+        LOG_INFO("Simulation mode enabled, starting simulated stream generator...");
+        pthread_t sim_thread;
+        if (pthread_create(&sim_thread, NULL, sim_image_thread_func, NULL) != 0) {
+            LOG_WARN("Failed to create simulation thread");
+        }
+    }
+    
+    /* ===== 主循环 ===== */
+    LOG_INFO("Main loop started, press Ctrl+C to stop");
+    
+    int loop_count = 0;
+    while (g_running) {
+        sleep_milliseconds(1000);
+        loop_count++;
+        
+        /* 定期打印状态 */
+        if (loop_count % 60 == 0) {
+            int total, unack, today;
+            alarm_get_stats(&total, &unack, &today);
+            
+            get_timestamp(timebuf, sizeof(timebuf), NULL);
+            LOG_INFO("[%s] Status: TotalAlarms=%d, Unack=%d, Today=%d",
+                     timebuf, total, unack, today);
+        }
+    }
+    
+    /* ===== 清理 ===== */
+cleanup_alarm:
+    alarm_stop_listen();
+    alarm_cleanup();
+    
+cleanup_playback:
+    playback_cleanup();
+    
+cleanup_stream:
+    stream_cleanup();
+    
+cleanup_platform:
+    platform_cms_cleanup();
+    
+    /* 清理PID文件 */
+    unlink("./logs/isup_client.pid");
+    
+    get_timestamp(timebuf, sizeof(timebuf), NULL);
+    printf("==================================================\n");
+    printf("  %s stopped: %s\n", PROJECT_NAME, timebuf);
+    printf("==================================================\n");
+    
+    return 0;
+    
+    /*  unreachable */
+cleanup_stream:
+    stream_cleanup();
+cleanup_platform:
+    platform_cms_cleanup();
+    unlink("./logs/isup_client.pid");
+    return 1;
+}

src/platform.c

@@ -0,0 +1,457 @@
+#include "platform.h"
+#include <pthread.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+/* ============================================================
+ * 内部数据结构
+ * ============================================================ */
+
+/* 已注册设备信息 */
+typedef struct {
+    char device_id[MAX_DEVICE_ID];
+    int  user_id;
+    time_t register_time;
+    time_t last_heartbeat;
+    int  is_online;
+    DevRegInfo info;
+    pthread_mutex_t lock;
+} RegisteredDevice;
+
+/* 全局变量 */
+static int g_cms_initialized = 0;
+static int g_cms_listen_socket = -1;
+static pthread_t g_cms_listen_thread;
+static int g_cms_stop = 0;
+
+static DEVICE_REGISTER_CB g_reg_callback = NULL;
+static void* g_reg_user_data = NULL;
+
+static DeviceStatusCB g_status_callback = NULL;
+static void* g_status_user_data = NULL;
+
+static RegisteredDevice g_devices[256];
+static int g_device_count = 0;
+
+static int g_user_id_counter = 0;
+
+/* ============================================================
+ * HCNetSDK ISUP接口声明(外部动态库)
+ * ============================================================
+ * 实际编译时需要链接HCNetSDK库:
+ *   - libhcnetsdk.so (Linux)
+ *   - 头文件: HCNetSDK.h
+ * 
+ * 以下为ISUP SDK的核心接口声明:
+ * ============================================================ */
+
+/* CMS库接口 */
+extern int NET_ECMS_Init(void);
+extern void NET_ECMS_Clean(void);
+extern int NET_ECMS_StartListen(char* pszListenIP, short sListenPort, void* pUser);
+extern void NET_ECMS_StopListen(void);
+extern int NET_ECMS_Login(char* pszDVRIP, short sDVRPort, char* szUserName, char* szPassword, void* pUser);
+extern int NET_ECMS_Logout(int iUserID);
+extern int NET_ECMS_SetAutoReconnect(int iUserID, int bAutoReconnect, int iInterval);
+extern int NET_ECMS_SendHeartBeat(int iUserID);
+
+/* 流媒体库接口 */
+extern int NET_ESTREAM_Init(void);
+extern void NET_ESTREAM_Clean(void);
+extern int NET_ESTREAM_StartListenPlayBack(char* pszListenIP, short sListenPort, void* pCallback, void* pUser);
+extern void NET_ESTREAM_StopListenPlayBack(void);
+extern int NET_ESTREAM_SetPlayBackDataCB(int iStreamHandle, void* pCallback, void* pUser);
+extern int NET_ECMS_StartPlayBack(int iUserID, char* pszDevIP, short sDevPort, char* pszPlayBackIP, short sPlayBackPort, int iChannel);
+extern int NET_ECMS_StopPlayBack(int iUserID);
+
+/* 报警库接口 */
+extern int NET_EALARM_Init(void);
+extern void NET_EALARM_Clean(void);
+extern int NET_EALARM_StartListen(char* pszListenIP, short sListenPort, void* pAlarmCallback, void* pUser);
+extern void NET_EALARM_StopListen(void);
+
+/* 模拟实现(无实际SDK时的测试用) */
+#ifndef HAVE_HCNETSDK
+/* 如果没有实际SDK，使用模拟实现 */
+
+int NET_ECMS_Init(void) {
+    LOG_INFO("[Mock] NET_ECMS_Init called");
+    return SUCCESS;
+}
+
+void NET_ECMS_Clean(void) {
+    LOG_INFO("[Mock] NET_ECMS_Clean called");
+}
+
+int NET_ECMS_StartListen(char* pszListenIP, short sListenPort, void* pUser) {
+    LOG_INFO("[Mock] NET_ECMS_StartListen: IP=%s, Port=%d", pszListenIP, sListenPort);
+    return SUCCESS;
+}
+
+void NET_ECMS_StopListen(void) {
+    LOG_INFO("[Mock] NET_ECMS_StopListen called");
+}
+
+int NET_ECMS_Login(char* pszDVRIP, short sDVRPort, char* szUserName, char* szPassword, void* pUser) {
+    LOG_INFO("[Mock] NET_ECMS_Login: IP=%s, Port=%d", pszDVRIP, sDVRPort);
+    return ++g_user_id_counter;  /* 模拟返回用户ID */
+}
+
+int NET_ECMS_Logout(int iUserID) {
+    LOG_INFO("[Mock] NET_ECMS_Logout: UserID=%d", iUserID);
+    return SUCCESS;
+}
+
+int NET_ECMS_SetAutoReconnect(int iUserID, int bAutoReconnect, int iInterval) {
+    LOG_INFO("[Mock] NET_ECMS_SetAutoReconnect: UserID=%d, Enable=%d, Interval=%d", 
+             iUserID, bAutoReconnect, iInterval);
+    return SUCCESS;
+}
+
+int NET_ECMS_SendHeartBeat(int iUserID) {
+    LOG_INFO("[Mock] NET_ECMS_SendHeartBeat: UserID=%d", iUserID);
+    return SUCCESS;
+}
+
+int NET_ESTREAM_Init(void) {
+    LOG_INFO("[Mock] NET_ESTREAM_Init called");
+    return SUCCESS;
+}
+
+void NET_ESTREAM_Clean(void) {
+    LOG_INFO("[Mock] NET_ESTREAM_Clean called");
+}
+
+int NET_ESTREAM_StartListenPlayBack(char* pszListenIP, short sListenPort, void* pCallback, void* pUser) {
+    LOG_INFO("[Mock] NET_ESTREAM_StartListenPlayBack: IP=%s, Port=%d", pszListenIP, sListenPort);
+    return SUCCESS;
+}
+
+void NET_ESTREAM_StopListenPlayBack(void) {
+    LOG_INFO("[Mock] NET_ESTREAM_StopListenPlayBack called");
+}
+
+int NET_ESTREAM_SetPlayBackDataCB(int iStreamHandle, void* pCallback, void* pUser) {
+    LOG_INFO("[Mock] NET_ESTREAM_SetPlayBackDataCB: Handle=%d", iStreamHandle);
+    return SUCCESS;
+}
+
+int NET_ECMS_StartPlayBack(int iUserID, char* pszDevIP, short sDevPort, char* pszPlayBackIP, short sPlayBackPort, int iChannel) {
+    LOG_INFO("[Mock] NET_ECMS_StartPlayBack: UserID=%d, Channel=%d", iUserID, iChannel);
+    return SUCCESS;
+}
+
+int NET_ECMS_StopPlayBack(int iUserID) {
+    LOG_INFO("[Mock] NET_ECMS_StopPlayBack: UserID=%d", iUserID);
+    return SUCCESS;
+}
+
+int NET_EALARM_Init(void) {
+    LOG_INFO("[Mock] NET_EALARM_Init called");
+    return SUCCESS;
+}
+
+void NET_EALARM_Clean(void) {
+    LOG_INFO("[Mock] NET_EALARM_Clean called");
+}
+
+int NET_EALARM_StartListen(char* pszListenIP, short sListenPort, void* pAlarmCallback, void* pUser) {
+    LOG_INFO("[Mock] NET_EALARM_StartListen: IP=%s, Port=%d", pszListenIP, sListenPort);
+    return SUCCESS;
+}
+
+void NET_EALARM_StopListen(void) {
+    LOG_INFO("[Mock] NET_EALARM_StopListen called");
+}
+
+#endif /* HAVE_HCNETSDK */
+
+/* ============================================================
+ * 内部函数
+ * ============================================================ */
+
+static RegisteredDevice* find_device(const char* device_id) {
+    for (int i = 0; i < g_device_count; i++) {
+        if (strcmp(g_devices[i].device_id, device_id) == 0) {
+            return &g_devices[i];
+        }
+    }
+    return NULL;
+}
+
+static int add_device(const char* device_id, int user_id) {
+    if (g_device_count >= 256) {
+        LOG_ERROR("Maximum device count reached");
+        return FAILURE;
+    }
+    
+    RegisteredDevice* dev = &g_devices[g_device_count];
+    safe_strcpy(dev->device_id, device_id, MAX_DEVICE_ID);
+    dev->user_id = user_id;
+    dev->register_time = time(NULL);
+    dev->last_heartbeat = time(NULL);
+    dev->is_online = 1;
+    pthread_mutex_init(&dev->lock, NULL);
+    
+    g_device_count++;
+    LOG_INFO("Device registered: %s (UserID=%d, Total=%d)", device_id, user_id, g_device_count);
+    return SUCCESS;
+}
+
+static void remove_device(const char* device_id) {
+    for (int i = 0; i < g_device_count; i++) {
+        if (strcmp(g_devices[i].device_id, device_id) == 0) {
+            pthread_mutex_destroy(&g_devices[i].lock);
+            g_device_count--;
+            /* 移动最后一个元素到删除位置 */
+            if (i < g_device_count) {
+                memcpy(&g_devices[i], &g_devices[g_device_count], sizeof(RegisteredDevice));
+            }
+            LOG_INFO("Device removed: %s (Total=%d)", device_id, g_device_count);
+            return;
+        }
+    }
+}
+
+/* CMS监听线程函数 */
+static void* cms_listen_thread_func(void* arg) {
+    LOG_INFO("CMS listen thread started");
+    
+    while (!g_cms_stop) {
+        /* 在实际实现中，这里会阻塞等待设备注册请求 */
+        /* 模拟实现中，我们只是休眠并检查停止标志 */
+        sleep_milliseconds(1000);
+        
+        /* 检查心跳超时 */
+        time_t now = time(NULL);
+        for (int i = 0; i < g_device_count; i++) {
+            if (g_devices[i].is_online && (now - g_devices[i].last_heartbeat > 90)) {
+                LOG_WARN("Device heartbeat timeout: %s", g_devices[i].device_id);
+                g_devices[i].is_online = 0;
+                
+                if (g_status_callback) {
+                    g_status_callback(g_devices[i].device_id, DEVICE_STATUS_OFFLINE, g_status_user_data);
+                }
+            }
+        }
+    }
+    
+    LOG_INFO("CMS listen thread stopped");
+    return NULL;
+}
+
+/* ============================================================
+ * 公共接口实现
+ * ============================================================ */
+
+int platform_cms_init(void) {
+    if (g_cms_initialized) {
+        LOG_WARN("CMS already initialized");
+        return SUCCESS;
+    }
+    
+    LOG_INFO("Initializing CMS library...");
+    
+    /* 调用HCNetSDK初始化 */
+    if (NET_ECMS_Init() != SUCCESS) {
+        LOG_ERROR("Failed to initialize CMS library");
+        return FAILURE;
+    }
+    
+    /* 初始化报警库 */
+    if (NET_EALARM_Init() != SUCCESS) {
+        LOG_WARN("Failed to initialize ALARM library (non-fatal)");
+    }
+    
+    g_cms_initialized = 1;
+    LOG_INFO("CMS library initialized successfully");
+    return SUCCESS;
+}
+
+void platform_cms_cleanup(void) {
+    if (!g_cms_initialized) return;
+    
+    LOG_INFO("Cleaning up CMS library...");
+    
+    g_cms_stop = 1;
+    
+    if (g_cms_listen_socket >= 0) {
+        close(g_cms_listen_socket);
+        g_cms_listen_socket = -1;
+    }
+    
+    if (g_cms_listen_thread != 0) {
+        pthread_join(g_cms_listen_thread, NULL);
+        g_cms_listen_thread = 0;
+    }
+    
+    /* 清理所有设备 */
+    for (int i = 0; i < g_device_count; i++) {
+        pthread_mutex_destroy(&g_devices[i].lock);
+    }
+    g_device_count = 0;
+    
+    /* 调用HCNetSDK清理 */
+    NET_ECMS_Clean();
+    NET_EALARM_Clean();
+    
+    g_cms_initialized = 0;
+    LOG_INFO("CMS library cleaned up");
+}
+
+int platform_cms_start_listen(const char* listen_ip, short listen_port,
+                              DEVICE_REGISTER_CB reg_callback, void* user_data) {
+    if (listen_ip == NULL || reg_callback == NULL) {
+        LOG_ERROR("Invalid parameters");
+        return FAILURE;
+    }
+    
+    g_reg_callback = reg_callback;
+    g_reg_user_data = user_data;
+    
+    LOG_INFO("Starting CMS listen on %s:%d...", listen_ip, listen_port);
+    
+    /* 调用HCNetSDK启动监听 */
+    if (NET_ECMS_StartListen((char*)listen_ip, listen_port, NULL) != SUCCESS) {
+        LOG_ERROR("Failed to start CMS listen");
+        return FAILURE;
+    }
+    
+    /* 启动监听线程 */
+    g_cms_stop = 0;
+    if (pthread_create(&g_cms_listen_thread, NULL, cms_listen_thread_func, NULL) != 0) {
+        LOG_ERROR("Failed to create CMS listen thread");
+        return FAILURE;
+    }
+    
+    LOG_INFO("CMS listen started successfully");
+    return SUCCESS;
+}
+
+void platform_cms_stop_listen(void) {
+    LOG_INFO("Stopping CMS listen...");
+    g_cms_stop = 1;
+    
+    if (g_cms_listen_socket >= 0) {
+        close(g_cms_listen_socket);
+        g_cms_listen_socket = -1;
+    }
+    
+    LOG_INFO("CMS listen stopped");
+}
+
+int platform_device_register(const char* server_ip, short server_port,
+                             const char* device_id, const char* protocol_version,
+                             const char* encrypt_key, void* user_data) {
+    if (server_ip == NULL || device_id == NULL) {
+        LOG_ERROR("Invalid parameters");
+        return FAILURE;
+    }
+    
+    LOG_INFO("Registering device: %s to CMS %s:%d", device_id, server_ip, server_port);
+    
+    /* 检查是否已注册 */
+    if (find_device(device_id) != NULL) {
+        LOG_WARN("Device already registered: %s", device_id);
+        return FAILURE;
+    }
+    
+    /* 调用HCNetSDK登录 */
+    int user_id = NET_ECMS_Login((char*)server_ip, server_port, 
+                                  (char*)device_id, (char*)encrypt_key, user_data);
+    
+    if (user_id < 0) {
+        LOG_ERROR("Device registration failed: %s", device_id);
+        return FAILURE;
+    }
+    
+    /* 记录设备信息 */
+    add_device(device_id, user_id);
+    
+    /* 设置自动重连 */
+    NET_ECMS_SetAutoReconnect(user_id, 1, REG_RETRY_INTERVAL);
+    
+    /* 触发注册回调 */
+    if (g_reg_callback) {
+        g_reg_callback(user_id, DEV_REG_TYPE_ON, NULL, 0, NULL, 0, user_data);
+    }
+    
+    /* 触发状态回调 */
+    if (g_status_callback) {
+        g_status_callback(device_id, DEVICE_STATUS_ONLINE, g_status_user_data);
+    }
+    
+    LOG_INFO("Device registered successfully: %s (UserID=%d)", device_id, user_id);
+    return user_id;
+}
+
+int platform_device_logout(int user_id) {
+    if (user_id < 0) {
+        LOG_ERROR("Invalid user ID");
+        return FAILURE;
+    }
+    
+    LOG_INFO("Logging out device: UserID=%d", user_id);
+    
+    /* 查找设备 */
+    for (int i = 0; i < g_device_count; i++) {
+        if (g_devices[i].user_id == user_id) {
+            /* 触发下线回调 */
+            if (g_reg_callback) {
+                g_reg_callback(user_id, DEV_REG_TYPE_OFF, NULL, 0, NULL, 0, g_reg_user_data);
+            }
+            
+            if (g_status_callback) {
+                g_status_callback(g_devices[i].device_id, DEVICE_STATUS_OFFLINE, g_status_user_data);
+            }
+            
+            remove_device(g_devices[i].device_id);
+            break;
+        }
+    }
+    
+    /* 调用HCNetSDK登出 */
+    NET_ECMS_Logout(user_id);
+    
+    LOG_INFO("Device logged out: UserID=%d", user_id);
+    return SUCCESS;
+}
+
+int platform_set_auto_reconnect(int user_id, int enable, int interval) {
+    return NET_ECMS_SetAutoReconnect(user_id, enable, interval);
+}
+
+int platform_send_heartbeat(int user_id) {
+    return NET_ECMS_SendHeartBeat(user_id);
+}
+
+void platform_register_status_callback(DeviceStatusCB cb, void* user_data) {
+    g_status_callback = cb;
+    g_status_user_data = user_data;
+}
+
+int platform_get_device_info(const char* device_id, DevRegInfo* info) {
+    if (device_id == NULL || info == NULL) {
+        return FAILURE;
+    }
+    
+    RegisteredDevice* dev = find_device(device_id);
+    if (dev == NULL) {
+        return NOT_FOUND;
+    }
+    
+    memcpy(info, &dev->info, sizeof(DevRegInfo));
+    return SUCCESS;
+}
+
+int platform_get_online_devices(char devices[][MAX_DEVICE_ID], int max_devices) {
+    int count = 0;
+    for (int i = 0; i < g_device_count && count < max_devices; i++) {
+        if (g_devices[i].is_online) {
+            safe_strcpy(devices[count], g_devices[i].device_id, MAX_DEVICE_ID);
+            count++;
+        }
+    }
+    return count;
+}

src/playback.c

@@ -0,0 +1,330 @@
+#include "playback.h"
+#include <pthread.h>
+#include <dirent.h>
+#include <sys/stat.h>
+
+/* ============================================================
+ * 内部数据结构
+ * ============================================================ */
+
+#define MAX_ACTIVE_PLAYBACKS 32
+
+static PlaybackSession* g_active_playbacks[MAX_ACTIVE_PLAYBACKS];
+static int g_playback_count = 0;
+static int g_playback_id_counter = 0;
+
+static pthread_mutex_t g_playback_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/* ============================================================
+ * 内部函数
+ * ============================================================ */
+
+static PlaybackSession* find_playback(int playback_id) {
+    for (int i = 0; i < g_playback_count; i++) {
+        if (g_active_playbacks[i] != NULL && g_active_playbacks[i]->playback_id == playback_id) {
+            return g_active_playbacks[i];
+        }
+    }
+    return NULL;
+}
+
+static int add_playback(PlaybackSession* session) {
+    pthread_mutex_lock(&g_playback_mutex);
+    
+    if (g_playback_count >= MAX_ACTIVE_PLAYBACKS) {
+        pthread_mutex_unlock(&g_playback_mutex);
+        LOG_ERROR("Maximum playback sessions reached");
+        return FAILURE;
+    }
+    
+    session->playback_id = ++g_playback_id_counter;
+    session->state = PLAYBACK_STATE_IDLE;
+    session->is_running = 0;
+    session->frame_count = 0;
+    pthread_mutex_init(&session->lock, NULL);
+    
+    g_active_playbacks[g_playback_count++] = session;
+    
+    pthread_mutex_unlock(&g_playback_mutex);
+    LOG_INFO("Playback session added: ID=%d, Device=%s, Channel=%d",
+             session->playback_id, session->device_id, session->channel);
+    return SUCCESS;
+}
+
+static void remove_playback(int playback_id) {
+    pthread_mutex_lock(&g_playback_mutex);
+    
+    for (int i = 0; i < g_playback_count; i++) {
+        if (g_active_playbacks[i] != NULL && g_active_playbacks[i]->playback_id == playback_id) {
+            pthread_mutex_destroy(&g_active_playbacks[i]->lock);
+            g_active_playbacks[i] = NULL;
+            g_playback_count--;
+            
+            /* 压缩数组 */
+            int write_idx = 0;
+            for (int read_idx = 0; read_idx < g_playback_count; read_idx++) {
+                if (g_active_playbacks[read_idx] != NULL) {
+                    g_active_playbacks[write_idx++] = g_active_playbacks[read_idx];
+                }
+            }
+            for (int j = write_idx; j < g_playback_count; j++) {
+                g_active_playbacks[j] = NULL;
+            }
+            
+            LOG_INFO("Playback session removed: ID=%d", playback_id);
+            break;
+        }
+    }
+    
+    pthread_mutex_unlock(&g_playback_mutex);
+}
+
+/* ============================================================
+ * 公共接口实现
+ * ============================================================ */
+
+int playback_init(void) {
+    LOG_INFO("Initializing playback module...");
+    
+    g_playback_count = 0;
+    memset(g_active_playbacks, 0, sizeof(g_active_playbacks));
+    
+    /* 确保录像目录存在 */
+    /* 目录由配置决定 */
+    
+    LOG_INFO("Playback module initialized");
+    return SUCCESS;
+}
+
+void playback_cleanup(void) {
+    LOG_INFO("Cleaning up playback module...");
+    
+    playback_stop_all();
+    
+    for (int i = 0; i < MAX_ACTIVE_PLAYBACKS; i++) {
+        if (g_active_playbacks[i] != NULL) {
+            pthread_mutex_destroy(&g_active_playbacks[i]->lock);
+            if (g_active_playbacks[i]->stream) {
+                stream_destroy_session(g_active_playbacks[i]->stream);
+            }
+            free(g_active_playbacks[i]);
+            g_active_playbacks[i] = NULL;
+        }
+    }
+    
+    g_playback_count = 0;
+    
+    LOG_INFO("Playback module cleaned up");
+}
+
+PlaybackSession* playback_start(const char* device_id, int channel,
+                                 time_t start_time, time_t end_time,
+                                 int speed,
+                                 PlaybackDataCB data_cb,
+                                 PlaybackStatusCB status_cb,
+                                 void* user_data) {
+    if (device_id == NULL || channel < 0) {
+        LOG_ERROR("Invalid parameters");
+        return NULL;
+    }
+    
+    LOG_INFO("Starting playback: Device=%s, Channel=%d, Start=%ld, End=%ld, Speed=%d",
+             device_id, channel, (long)start_time, (long)end_time, speed);
+    
+    PlaybackSession* session = (PlaybackSession*)calloc(1, sizeof(PlaybackSession));
+    if (session == NULL) {
+        LOG_ERROR("Failed to allocate playback session");
+        return NULL;
+    }
+    
+    safe_strcpy(session->device_id, device_id, MAX_DEVICE_ID);
+    session->channel = channel;
+    session->start_time = start_time;
+    session->end_time = end_time;
+    session->speed = speed;
+    session->state = PLAYBACK_STATE_STARTING;
+    
+    /* 创建关联的流会话用于接收回放数据 */
+    session->stream = stream_create_session(device_id, channel, STREAM_TYPE_SUB, 
+                                             CODEC_TYPE_H264, 1920, 1080, 25, 2048000);
+    
+    if (session->stream == NULL) {
+        LOG_ERROR("Failed to create stream session for playback");
+        free(session);
+        return NULL;
+    }
+    
+    /* 设置回放数据回调 */
+    if (data_cb != NULL) {
+        /* 在实际实现中，这里会注册到流媒体库的回调 */
+        session->stream->internal_handle = (void*)data_cb;
+    }
+    
+    if (add_playback(session) != SUCCESS) {
+        stream_destroy_session(session->stream);
+        free(session);
+        return NULL;
+    }
+    
+    /* 调用HCNetSDK启动回放
+     * 完整流程:
+     * 1. NET_ESTREAM_StartListenPlayBack - 开启SMS回放监听
+     * 2. NET_ESTREAM_SetExceptionCallBack - 注册异常回调
+     * 3. NET_ECMS_StartPlayBack - 向设备发送回放开始请求
+     * 4. NET_ESTREAM_SetPlayBackDataCB - 注册回放数据回调
+     * 5. NET_ECMS_StartPushPlayBack - 发送码流传输请求(可选)
+     */
+    
+    /* 步骤1: 开启SMS回放监听 */
+    stream_start_playback_listen("0.0.0.0", 7660, NULL, NULL);
+    
+    /* 步骤2: 向设备发送回放开始请求 */
+    /* NET_ECMS_StartPlayBack(user_id, dev_ip, dev_port, sms_ip, sms_port, channel) */
+    
+    session->state = PLAYBACK_STATE_PLAYING;
+    session->is_running = 1;
+    
+    /* 触发状态回调 */
+    if (status_cb) {
+        status_cb(session, PLAYBACK_STATE_PLAYING, user_data);
+    }
+    
+    LOG_INFO("Playback started: ID=%d, Device=%s, Channel=%d",
+             session->playback_id, device_id, channel);
+    
+    return session;
+}
+
+int playback_stop(PlaybackSession* session) {
+    if (session == NULL) return FAILURE;
+    
+    LOG_INFO("Stopping playback: ID=%d, Device=%s, Channel=%d",
+             session->playback_id, session->device_id, session->channel);
+    
+    session->is_running = 0;
+    session->state = PLAYBACK_STATE_STOPPING;
+    
+    /* 步骤7: 停止SMS码流转发 */
+    /* NET_ESTREAM_StopPlayBack() */
+    
+    /* 步骤8: 向设备发送回放停止请求 */
+    /* NET_ECMS_StopPlayBack(user_id) */
+    
+    /* 停止关联的流 */
+    if (session->stream) {
+        stream_stop_push(session->stream);
+        stream_destroy_session(session->stream);
+        session->stream = NULL;
+    }
+    
+    /* 步骤9: 停止SMS回放监听(如果没有其他回放在使用) */
+    /* NET_ESTREAM_StopListenPlayBack() */
+    
+    remove_playback(session->playback_id);
+    free(session);
+    
+    LOG_INFO("Playback stopped: ID=%d", session->playback_id);
+    return SUCCESS;
+}
+
+int playback_pause(PlaybackSession* session) {
+    if (session == NULL) return FAILURE;
+    
+    if (session->state != PLAYBACK_STATE_PLAYING) {
+        return FAILURE;
+    }
+    
+    LOG_INFO("Pausing playback: ID=%d", session->playback_id);
+    session->state = PLAYBACK_STATE_PAUSED;
+    
+    /* 在实际实现中，这里会暂停码流转发 */
+    
+    return SUCCESS;
+}
+
+int playback_resume(PlaybackSession* session) {
+    if (session == NULL) return FAILURE;
+    
+    if (session->state != PLAYBACK_STATE_PAUSED) {
+        return FAILURE;
+    }
+    
+    LOG_INFO("Resuming playback: ID=%d", session->playback_id);
+    session->state = PLAYBACK_STATE_PLAYING;
+    
+    /* 在实际实现中，这里会恢复码流转发 */
+    
+    return SUCCESS;
+}
+
+int playback_get_file_list(const char* device_id, int channel,
+                           time_t start_time, time_t end_time,
+                           char files[][MAX_PATH_SIZE], int max_files) {
+    if (device_id == NULL || files == NULL) {
+        return FAILURE;
+    }
+    
+    LOG_INFO("Getting file list: Device=%s, Channel=%d, Start=%ld, End=%ld",
+             device_id, channel, (long)start_time, (long)end_time);
+    
+    /* 在实际实现中，这里会调用HCNetSDK查询录像文件
+     * 例如: NET_DVR_FindFirstFile / NET_DVR_FindNextFile / NET_DVR_FindClose
+     */
+    
+    /* 模拟实现: 返回空列表 */
+    (void)start_time;
+    (void)end_time;
+    (void)max_files;
+    
+    return 0;
+}
+
+int playback_download_file(const char* device_id, int channel,
+                           const char* file_name, const char* save_path) {
+    if (device_id == NULL || file_name == NULL || save_path == NULL) {
+        return FAILURE;
+    }
+    
+    LOG_INFO("Downloading file: Device=%s, Channel=%d, File=%s, Path=%s",
+             device_id, channel, file_name, save_path);
+    
+    /* 在实际实现中，这里会调用HCNetSDK下载录像文件
+     * 例如: NET_DVR_PlayBackByTime / NET_DVR_SaveRealData
+     */
+    
+    return SUCCESS;
+}
+
+int playback_get_active_sessions(PlaybackSession* sessions[], int max_sessions) {
+    int count = 0;
+    pthread_mutex_lock(&g_playback_mutex);
+    
+    for (int i = 0; i < g_playback_count && count < max_sessions; i++) {
+        if (g_active_playbacks[i] != NULL) {
+            sessions[count++] = g_active_playbacks[i];
+        }
+    }
+    
+    pthread_mutex_unlock(&g_playback_mutex);
+    return count;
+}
+
+void playback_stop_all(void) {
+    pthread_mutex_lock(&g_playback_mutex);
+    
+    for (int i = 0; i < g_playback_count; i++) {
+        if (g_active_playbacks[i] != NULL) {
+            g_active_playbacks[i]->is_running = 0;
+            if (g_active_playbacks[i]->stream) {
+                stream_stop_push(g_active_playbacks[i]->stream);
+            }
+        }
+    }
+    
+    pthread_mutex_unlock(&g_playback_mutex);
+}
+
+PlaybackState playback_get_state(PlaybackSession* session) {
+    if (session == NULL) return PLAYBACK_STATE_ERROR;
+    return session->state;
+}

src/stream.c

@@ -0,0 +1,549 @@
+#include "stream.h"
+#include <pthread.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+
+/* ============================================================
+ * 内部数据结构
+ * ============================================================ */
+
+#define MAX_SESSIONS 128
+
+static StreamSession* g_sessions[MAX_SESSIONS];
+static int g_session_count = 0;
+static int g_session_id_counter = 0;
+
+static pthread_mutex_t g_session_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/* RTMP推流相关(模拟zlmediakit推流) */
+typedef struct {
+    int socket_fd;
+    char server_ip[MAX_IP_SIZE];
+    short server_port;
+    char app_name[64];
+    char stream_key[128];
+    int is_connected;
+    pthread_t push_thread;
+    int stop_push;
+} RTMPPushContext;
+
+/* ============================================================
+ * PS封装相关常量
+ * ============================================================ */
+
+/* MPEG-2 PS流包头常量 */
+#define PS_PACKET_SIZE        2048
+#define PS_SYSTEM_HEADER      0x00
+#define PS_PACK_START_CODE    0x000001BA
+#define PS_SYSTEM_HEADER_CODE 0x000001BB
+#define PS_PROGRAM_STREAM_MAP 0x000001BC
+#define PS_PRIVATE_STREAM_1   0x000001BD
+#define PS_PADDING_STREAM     0x000001BE
+#define PS_PRIVATE_STREAM_2   0x000001BF
+#define PS_PROGRAM_STREAM_DIRECTORY 0x000001BF
+#define PS_END_OF_STREAM      0x000001B9
+#define PS_PACK_HEADER        0x000001E0
+
+/* H.264 NALU类型 */
+#define H264_NALU_START       0x000001
+#define H264_NALU_START_4     0x00000001
+#define H264_NALU_END_CODE    0x000001B9
+
+/* ============================================================
+ * 内部函数
+ * ============================================================ */
+
+static StreamSession* find_session(int stream_id) {
+    for (int i = 0; i < g_session_count; i++) {
+        if (g_sessions[i] != NULL && g_sessions[i]->stream_id == stream_id) {
+            return g_sessions[i];
+        }
+    }
+    return NULL;
+}
+
+static int add_session(StreamSession* session) {
+    pthread_mutex_lock(&g_session_mutex);
+    
+    if (g_session_count >= MAX_SESSIONS) {
+        pthread_mutex_unlock(&g_session_mutex);
+        LOG_ERROR("Maximum session count reached");
+        return FAILURE;
+    }
+    
+    session->stream_id = ++g_session_id_counter;
+    session->state = STREAM_STATE_IDLE;
+    session->is_running = 0;
+    pthread_mutex_init(&session->lock, NULL);
+    
+    g_sessions[g_session_count++] = session;
+    
+    pthread_mutex_unlock(&g_session_mutex);
+    LOG_INFO("Session added: ID=%d, Device=%s, Channel=%d", 
+             session->stream_id, session->device_id, session->channel);
+    return SUCCESS;
+}
+
+static void remove_session(int stream_id) {
+    pthread_mutex_lock(&g_session_mutex);
+    
+    for (int i = 0; i < g_session_count; i++) {
+        if (g_sessions[i] != NULL && g_sessions[i]->stream_id == stream_id) {
+            g_sessions[i] = NULL;
+            g_session_count--;
+            
+            /* 压缩数组 */
+            int write_idx = 0;
+            for (int read_idx = 0; read_idx < g_session_count; read_idx++) {
+                if (g_sessions[read_idx] != NULL) {
+                    g_sessions[write_idx++] = g_sessions[read_idx];
+                }
+            }
+            for (int j = write_idx; j < g_session_count; j++) {
+                g_sessions[j] = NULL;
+            }
+            
+            LOG_INFO("Session removed: ID=%d", stream_id);
+            break;
+        }
+    }
+    
+    pthread_mutex_unlock(&g_session_mutex);
+}
+
+/* ============================================================
+ * PS封装函数实现
+ * ============================================================ */
+
+/**
+ * @brief 将H.264 NALU封装为PS包
+ * 
+ * PS(Program Stream)格式结构:
+ * - Pack Header (4-11 bytes)
+ * - Program Stream Map (可变长度)
+ * - PES Packet (可变长度)
+ *   - PES Header
+ *   - PES Payload (NALU数据)
+ * 
+ * 每个PS包固定2048字节(包括纠错码)
+ */
+static int pack_h264_to_ps(StreamSession* session, const uint8_t* nalu_data, int nalu_size) {
+    /* 简化实现: 将H.264 NALU数据封装为PS流包 */
+    /* 实际实现需要完整的MPEG-2 PS封装逻辑 */
+    
+    if (nalu_data == NULL || nalu_size <= 0) {
+        return -1;
+    }
+    
+    /* 在实际实现中，这里会:
+     * 1. 检查SPS/PPS，如有变化则生成PS系统头和PSMAP
+     * 2. 将NALU封装为PES包
+     * 3. 添加Pack Header
+     * 4. 填充到PS_PACKET_SIZE(2048字节)
+     * 5. 添加纠错码
+     */
+    
+    /* 模拟实现: 返回NALU大小作为"封装后大小" */
+    (void)session;
+    return nalu_size;
+}
+
+/* ============================================================
+ * RTMP推流模拟(对接zlmediakit)
+ * ============================================================ */
+
+/**
+ * @brief RTMP推流线程函数
+ * 
+ * 实际实现中需要链接zlmediakit的C API库:
+ * - zlm_sdk.h
+ * - libzlmediakit.so
+ * 
+ * 核心流程:
+ * 1. 连接到zlmediakit服务器
+ * 2. 创建媒体流
+ * 3. 循环发送视频帧
+ * 4. 处理断线重连
+ */
+static void* rtmp_push_thread_func(void* arg) {
+    StreamSession* session = (StreamSession*)arg;
+    RTMPPushContext* ctx = (RTMPPushContext*)session->internal_handle;
+    
+    if (ctx == NULL) {
+        LOG_ERROR("RTMP push context is NULL");
+        return NULL;
+    }
+    
+    char rtmp_url[512];
+    snprintf(rtmp_url, sizeof(rtmp_url), "rtmp://%s:%d/%s/%s",
+             ctx->server_ip, ctx->server_port, ctx->app_name, ctx->stream_key);
+    
+    LOG_INFO("RTMP push thread started: %s", rtmp_url);
+    
+    /* 模拟RTMP推流循环 */
+    while (!ctx->stop_push && session->is_running) {
+        /* 在实际实现中:
+         * 1. 从设备接收视频帧
+         * 2. 封装为PS流
+         * 3. 通过RTMP协议发送到zlmediakit
+         * 
+         * 使用zlmediakit C API:
+         * ZLMediaKit_API *api = ZLMediaKit_Create();
+         * api->Connect(api, ctx->server_ip, ctx->server_port);
+         * api->CreateMediaSource(api, ctx->app_name, ctx->stream_key);
+         * 
+         * 或者使用FFmpeg推流:
+         * avformat_alloc_output_context2(&fmt_ctx, NULL, "rtmp", rtmp_url);
+         * avformat_write_header(fmt_ctx, NULL);
+         * av_interleaved_write_frame(fmt_ctx, &packet);
+         */
+        
+        /* 模拟发送帧 */
+        if (session->state == STREAM_STATE_STREAMING) {
+            /* 这里应该有实际的帧发送逻辑 */
+            sleep_milliseconds(1000 / session->fps);
+        } else {
+            sleep_milliseconds(100);
+        }
+    }
+    
+    LOG_INFO("RTMP push thread stopped: %s", rtmp_url);
+    return NULL;
+}
+
+/* ============================================================
+ * 公共接口实现
+ * ============================================================ */
+
+int stream_init(void) {
+    LOG_INFO("Initializing stream management...");
+    
+    /* 初始化流媒体库 */
+    if (NET_ESTREAM_Init() != SUCCESS) {
+        LOG_ERROR("Failed to initialize stream library");
+        return FAILURE;
+    }
+    
+    g_session_count = 0;
+    memset(g_sessions, 0, sizeof(g_sessions));
+    
+    LOG_INFO("Stream management initialized");
+    return SUCCESS;
+}
+
+void stream_cleanup(void) {
+    LOG_INFO("Cleaning up stream management...");
+    
+    stream_stop_all();
+    
+    for (int i = 0; i < MAX_SESSIONS; i++) {
+        if (g_sessions[i] != NULL) {
+            pthread_mutex_destroy(&g_sessions[i]->lock);
+            free(g_sessions[i]);
+            g_sessions[i] = NULL;
+        }
+    }
+    
+    g_session_count = 0;
+    
+    NET_ESTREAM_Clean();
+    
+    LOG_INFO("Stream management cleaned up");
+}
+
+int stream_start_playback_listen(const char* listen_ip, short listen_port,
+                                  void* callback, void* user_data) {
+    if (listen_ip == NULL) {
+        LOG_ERROR("Invalid parameters");
+        return FAILURE;
+    }
+    
+    LOG_INFO("Starting playback listen on %s:%d...", listen_ip, listen_port);
+    
+    /* 调用HCNetSDK启动回放监听 */
+    if (NET_ESTREAM_StartListenPlayBack((char*)listen_ip, listen_port, callback, user_data) != SUCCESS) {
+        LOG_ERROR("Failed to start playback listen");
+        return FAILURE;
+    }
+    
+    LOG_INFO("Playback listen started successfully");
+    return SUCCESS;
+}
+
+void stream_stop_playback_listen(void) {
+    LOG_INFO("Stopping playback listen...");
+    NET_ESTREAM_StopListenPlayBack();
+    LOG_INFO("Playback listen stopped");
+}
+
+int stream_set_playback_data_cb(int stream_handle, StreamDataCB callback, void* user_data) {
+    if (callback == NULL) {
+        LOG_ERROR("Invalid callback");
+        return FAILURE;
+    }
+    
+    LOG_INFO("Setting playback data callback for handle=%d", stream_handle);
+    
+    /* 调用HCNetSDK设置回调 */
+    if (NET_ESTREAM_SetPlayBackDataCB(stream_handle, callback, user_data) != SUCCESS) {
+        LOG_ERROR("Failed to set playback data callback");
+        return FAILURE;
+    }
+    
+    return SUCCESS;
+}
+
+StreamSession* stream_create_session(const char* device_id, int channel,
+                                      StreamType stream_type, CodecType codec,
+                                      int width, int height, int fps, int bitrate) {
+    if (device_id == NULL || channel < 0) {
+        LOG_ERROR("Invalid parameters");
+        return NULL;
+    }
+    
+    StreamSession* session = (StreamSession*)calloc(1, sizeof(StreamSession));
+    if (session == NULL) {
+        LOG_ERROR("Failed to allocate session");
+        return NULL;
+    }
+    
+    safe_strcpy(session->device_id, device_id, MAX_DEVICE_ID);
+    session->channel = channel;
+    session->type = stream_type;
+    session->codec = codec;
+    session->width = width;
+    session->height = height;
+    session->fps = fps;
+    session->bitrate = bitrate;
+    session->internal_handle = NULL;
+    
+    if (add_session(session) != SUCCESS) {
+        free(session);
+        return NULL;
+    }
+    
+    LOG_INFO("Session created: ID=%d, Device=%s, Channel=%d, Type=%d, Codec=%d",
+             session->stream_id, device_id, channel, stream_type, codec);
+    
+    return session;
+}
+
+void stream_destroy_session(StreamSession* session) {
+    if (session == NULL) return;
+    
+    stream_stop_push(session);
+    
+    remove_session(session->stream_id);
+    pthread_mutex_destroy(&session->lock);
+    free(session);
+    
+    LOG_INFO("Session destroyed: ID=%d", session->stream_id);
+}
+
+int stream_start_push(StreamSession* session, const char* rtmp_url,
+                      RTMPPushCB callback, void* user_data) {
+    if (session == NULL || rtmp_url == NULL) {
+        LOG_ERROR("Invalid parameters");
+        return FAILURE;
+    }
+    
+    if (session->is_running) {
+        LOG_WARN("Stream already running: ID=%d", session->stream_id);
+        return SUCCESS;
+    }
+    
+    LOG_INFO("Starting stream push: Device=%s, Channel=%d, RTMP=%s",
+             session->device_id, session->channel, rtmp_url);
+    
+    /* 解析RTMP URL */
+    RTMPPushContext* ctx = (RTMPPushContext*)calloc(1, sizeof(RTMPPushContext));
+    if (ctx == NULL) {
+        LOG_ERROR("Failed to allocate RTMP context");
+        return FAILURE;
+    }
+    
+    /* 解析URL: rtmp://server:port/app/stream_key */
+    char url_copy[512];
+    safe_strcpy(url_copy, rtmp_url, sizeof(url_copy));
+    
+    char* p = strstr(url_copy, "://");
+    if (p) {
+        p += 3;
+        char* slash = strchr(p, '/');
+        if (slash) {
+            *slash = '\0';
+            char* colon = strchr(p, ':');
+            if (colon) {
+                *colon = '\0';
+                safe_strcpy(ctx->server_ip, p, MAX_IP_SIZE);
+                ctx->server_port = atoi(colon + 1);
+            } else {
+                safe_strcpy(ctx->server_ip, p, MAX_IP_SIZE);
+                ctx->server_port = DEFAULT_RTMP_PORT;
+            }
+            
+            char* app_start = slash + 1;
+            char* key_start = strchr(app_start, '/');
+            if (key_start) {
+                *key_start = '\0';
+                safe_strcpy(ctx->app_name, app_start, sizeof(ctx->app_name));
+                safe_strcpy(ctx->stream_key, key_start + 1, sizeof(ctx->stream_key));
+            } else {
+                safe_strcpy(ctx->app_name, app_start, sizeof(ctx->app_name));
+            }
+        }
+    }
+    
+    session->internal_handle = ctx;
+    session->state = STREAM_STATE_STARTING;
+    session->is_running = 1;
+    
+    /* 启动推流线程 */
+    ctx->stop_push = 0;
+    if (pthread_create(&ctx->push_thread, NULL, rtmp_push_thread_func, session) != 0) {
+        LOG_ERROR("Failed to create RTMP push thread");
+        session->is_running = 0;
+        session->state = STREAM_STATE_ERROR;
+        free(ctx);
+        session->internal_handle = NULL;
+        return FAILURE;
+    }
+    
+    session->state = STREAM_STATE_STREAMING;
+    
+    /* 触发回调 */
+    if (callback) {
+        callback(ctx->stream_key, 1, user_data);  /* 1 = connected */
+    }
+    
+    LOG_INFO("Stream push started: ID=%d, RTMP Server=%s:%d", 
+             session->stream_id, ctx->server_ip, ctx->server_port);
+    
+    return SUCCESS;
+}
+
+int stream_stop_push(StreamSession* session) {
+    if (session == NULL) return FAILURE;
+    
+    if (!session->is_running) {
+        return SUCCESS;
+    }
+    
+    LOG_INFO("Stopping stream push: ID=%d", session->stream_id);
+    
+    session->is_running = 0;
+    session->state = STREAM_STATE_STOPPING;
+    
+    RTMPPushContext* ctx = (RTMPPushContext*)session->internal_handle;
+    if (ctx) {
+        ctx->stop_push = 1;
+        if (ctx->push_thread != 0) {
+            pthread_join(ctx->push_thread, NULL);
+            ctx->push_thread = 0;
+        }
+        free(ctx);
+        session->internal_handle = NULL;
+    }
+    
+    session->state = STREAM_STATE_IDLE;
+    
+    LOG_INFO("Stream push stopped: ID=%d", session->stream_id);
+    return SUCCESS;
+}
+
+int stream_send_frame(StreamSession* session, StreamFrame* frame) {
+    if (session == NULL || frame == NULL) {
+        return FAILURE;
+    }
+    
+    if (session->state != STREAM_STATE_STREAMING) {
+        return FAILURE;
+    }
+    
+    /* 封装为PS流 */
+    /* 在实际实现中，这里会调用encode_to_ps将H.264数据封装为PS流 */
+    
+    RTMPPushContext* ctx = (RTMPPushContext*)session->internal_handle;
+    if (ctx && ctx->socket_fd >= 0) {
+        /* 通过RTMP发送帧数据 */
+        /* 实际实现中使用zlmediakit API或FFmpeg */
+    }
+    
+    return SUCCESS;
+}
+
+int stream_stop_channel(const char* device_id, int channel) {
+    if (device_id == NULL) return FAILURE;
+    
+    pthread_mutex_lock(&g_session_mutex);
+    for (int i = 0; i < g_session_count; i++) {
+        if (g_sessions[i] != NULL && 
+            strcmp(g_sessions[i]->device_id, device_id) == 0 &&
+            g_sessions[i]->channel == channel) {
+            stream_stop_push(g_sessions[i]);
+            break;
+        }
+    }
+    pthread_mutex_unlock(&g_session_mutex);
+    
+    return SUCCESS;
+}
+
+void stream_stop_all(void) {
+    pthread_mutex_lock(&g_session_mutex);
+    for (int i = 0; i < g_session_count; i++) {
+        if (g_sessions[i] != NULL) {
+            stream_stop_push(g_sessions[i]);
+        }
+    }
+    pthread_mutex_unlock(&g_session_mutex);
+}
+
+StreamState stream_get_state(StreamSession* session) {
+    if (session == NULL) return STREAM_STATE_ERROR;
+    return session->state;
+}
+
+int encode_to_ps(const uint8_t* input_data, int input_size,
+                 uint8_t* output_buf, int output_size) {
+    if (input_data == NULL || output_buf == NULL) {
+        return -1;
+    }
+    
+    if (input_size > output_size) {
+        return -1;
+    }
+    
+    /* 简化实现: 直接复制数据
+     * 实际实现需要完整的MPEG-2 PS封装:
+     * 1. 添加Pack Header
+     * 2. 添加PES Header
+     * 3. 封装NALU数据
+     * 4. 填充到2048字节
+     * 5. 添加CRC校验
+     */
+    memcpy(output_buf, input_data, input_size);
+    return input_size;
+}
+
+int decode_ps_to_frame(const uint8_t* ps_data, int ps_size,
+                       uint8_t* output_buf, int output_size) {
+    if (ps_data == NULL || output_buf == NULL) {
+        return -1;
+    }
+    
+    /* 简化实现: 直接复制数据
+     * 实际实现需要PS解复用:
+     * 1. 解析Pack Header
+     * 2. 解析PES Header
+     * 3. 提取NALU数据
+     * 4. 去除PS封装开销
+     */
+    if (ps_size > output_size) {
+        return -1;
+    }
+    memcpy(output_buf, ps_data, ps_size);
+    return ps_size;
+}

src/utils.c

@@ -0,0 +1,138 @@
+#include "common.h"
+#include <ctype.h>
+#include <sys/time.h>
+
+/* 全局日志回调 */
+LogCallback g_log_callback = NULL;
+
+void set_log_callback(LogCallback cb) {
+    g_log_callback = cb;
+}
+
+char* get_timestamp(char* buf, size_t bufsize, const char* fmt) {
+    time_t now = time(NULL);
+    struct tm* tm_info = localtime(&now);
+    
+    if (fmt == NULL) {
+        fmt = "%Y-%m-%d %H:%M:%S";
+    }
+    
+    strftime(buf, bufsize, fmt, tm_info);
+    return buf;
+}
+
+char* str_tolower(char* str) {
+    char* p = str;
+    while (*p) {
+        *p = tolower((unsigned char)*p);
+        p++;
+    }
+    return str;
+}
+
+size_t safe_strcpy(char* dest, const char* src, size_t size) {
+    if (size == 0 || src == NULL) return 0;
+    
+    size_t len = strlen(src);
+    if (len >= size) {
+        len = size - 1;
+    }
+    memcpy(dest, src, len);
+    dest[len] = '\0';
+    return len;
+}
+
+/* 简单的文件写入工具 */
+int write_file(const char* path, const char* content) {
+    FILE* fp = fopen(path, "w");
+    if (fp == NULL) {
+        LOG_ERROR("Failed to open file: %s, error: %s", path, strerror(errno));
+        return FAILURE;
+    }
+    
+    fprintf(fp, "%s", content);
+    fclose(fp);
+    return SUCCESS;
+}
+
+/* 读取配置文件(简单键值对格式) */
+char* read_config_value(const char* file, const char* key) {
+    static char value[256];
+    FILE* fp = fopen(file, "r");
+    if (fp == NULL) {
+        LOG_ERROR("Failed to open config file: %s", file);
+        return NULL;
+    }
+    
+    char line[512];
+    while (fgets(line, sizeof(line), fp)) {
+        /* 跳过注释和空行 */
+        if (line[0] == '#' || line[0] == ';' || line[0] == '\n') continue;
+        
+        /* 移除换行符 */
+        line[strcspn(line, "\n")] = '\0';
+        
+        char* eq = strchr(line, '=');
+        if (eq != NULL) {
+            *eq = '\0';
+            if (strcmp(line, key) == 0) {
+                safe_strcpy(value, eq + 1, sizeof(value));
+                fclose(fp);
+                return value;
+            }
+        }
+    }
+    
+    fclose(fp);
+    return NULL;
+}
+
+/* 确保目录存在 */
+int ensure_directory(const char* path) {
+    struct stat st;
+    if (stat(path, &st) == 0) {
+        return S_ISDIR(st.st_mode) ? SUCCESS : FAILURE;
+    }
+    
+    /* 递归创建目录 */
+    char tmp[MAX_PATH_SIZE];
+    safe_strcpy(tmp, path, sizeof(tmp));
+    
+    char* p = tmp;
+    while (*p) {
+        if (*p == '/') {
+            *p = '\0';
+            mkdir(tmp, 0755);
+            *p = '/';
+        }
+        p++;
+    }
+    mkdir(tmp, 0755);
+    return SUCCESS;
+}
+
+/* 生成唯一ID */
+static int g_id_counter = 0;
+int generate_id(void) {
+    return ++g_id_counter;
+}
+
+/* 睡眠(可中断) */
+int sleep_milliseconds(int ms) {
+    struct timespec ts;
+    ts.tv_sec = ms / 1000;
+    ts.tv_nsec = (ms % 1000) * 1000000L;
+    return nanosleep(&ts, NULL);
+}
+
+/* 获取当前毫秒时间戳 */
+long long get_current_ms(void) {
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return (long long)tv.tv_sec * 1000 + tv.tv_usec / 1000;
+}
+
+/* 获取当前秒时间戳 */
+long long get_current_s(void) {
+    return (long long)time(NULL);
+}