.gitignore

@@ -1,46 +1,8 @@
-# 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
+sim_images/
+isup.log
+config.local.ini
 .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/

CHANGELOG.md

@@ -1,27 +1,54 @@
-# 更新日志 (CHANGELOG)
+# Changelog
 
-## [1.1.0] - 2026-10-08
+## v1.2.0 - Raspberry Pi 5 compatibility + deep bug-fix pass
+Target: Raspberry Pi 5 (BCM2712, Cortex-A76, aarch64 LP64, 8GB) & Ubuntu 24.04.
 
-### 修复 (Fixed)
-- common.h 缺少 `<stdint.h>` 导致 `uint8_t` 未定义，编译失败 (B1)
-- main.c 重复/缺失 goto 标签导致编译失败；重写为单一 teardown 状态机 (B2)
-- main.c 后台线程未 join 造成退出崩溃；信号处理非 async-signal-safe (B3)
-- Makefile `BUILD_DIR` 定义顺序错误、仿真宏与代码不一致、缺失 test 目标 (B4)
-- stream.c/playback.c 数组压缩删除丢失相邻会话，造成泄漏与失联 (B5)
-- stream.c/playback.c `free()` 后读取字段的 use-after-free (B6)
-- config.h `pid_file` 类型错误 (B7)
-- utils.c 缺少 `<sys/stat.h>` (B8)
-- NET_E* 与 sleep_milliseconds 隐式声明(GCC14 硬错误)，新增 isup_sdk.h 集中声明 (B9)
-- PID 写/删路径不一致；多个已定义未使用函数接入实际调用；模拟线程除零兜底
+### Portability (new)
+- Added `include/portable.h` / `src/portable.c`: endian-safe big-endian wire
+  writers/readers (PS/PES fields built by shift, never by char* casts, so
+  correct under strict alignment and on any endianness); monotonic clock
+  (`CLOCK_MONOTONIC`) instead of wall clock; `nanosleep`-based sleep (usleep is
+  deprecated on newer glibc); `portable_thread_create` with explicit stack size
+  (256KB) so worker threads behave predictably on the 8GB board.
+- Fixed `PTHREAD_STACK_MIN` signed-vs-unsigned comparison (would break `-Werror`
+  on both x86_64 LP64 and aarch64).
+- All 64-bit logging uses `PRIu64` from `<inttypes.h>` (LP64-safe on aarch64).
 
-### 新增 (Added)
-- `-test` 自测模式覆盖 注册->推流->回放->报警->登出 全链路
-- `make test` 一键编译并自测
-- `alarm_ingest` / `stream_get_session` / `stream_find_by_channel` / `playback_get_session` 公共访问接口
+### Bug fixes found & repaired this pass (build-gated under -Wall -Wextra -Werror)
+1. `common.h` missing `<stdint.h>/<inttypes.h>` -> byte/64-bit types undefined.
+2. `platform.c` function-pointer type mismatch: `p_ecms_init` declared
+   `void*(*)(void)` but assigned `void*(*)(void*)` (incompatible-pointer-types)
+   and would mis-call the SDK init.
+3. `platform.c` `NET_ECMS_GetLastError ? ... : ...` took the address of a
+   function -> always true (dead ternary). Now calls the getter directly.
+4. `config.c` unused static `kv()` + leftover `sep/key` dead vars
+   (unused-function/unused-variable).
+5. `main.c` getopt string had a stray space `"c: tsh"` and no grouping ->
+   `-t`/`-s` parsing unreliable; corrected to `"c:tsh"`.
+6. `main.c` self-test set `g_cfg.simulate=1` BEFORE `config_defaults()` which
+   reset it to 0 -> self-test tried to dlopen the real SDK and failed. Reordered.
+7. `stream.c` push(): logged `s->channel` AFTER releasing `s->lock` ->
+   use-after-unlock race. Now snapshots channel/frames under the lock.
+8. `stream.c` / `playback.c` session-table removal previously shift-compacted
+   and dropped the tail slot (lost sessions + leaked mutexes). Now clear-in-place.
+9. `stream.c` `stream_stats` / `playback.c` `playback_get_session` /
+   `alarm.c` accessors triggered `-Wmisleading-indentation` (multi-`if` on one
+   line). Rebraced for clarity and warning-clean build.
+10. Alarm ring buffer overflow path now wraps `g_head` correctly (v1.0 lost
+    events on wrap).
 
-### 验证 (Verified)
-- Ubuntu 24.04 / GCC 14：`make simulate` 零警告零错误
-- `./hikvision-isup-client -test` 全链路通过，进程干净退出(exit 0)
+### Structure
+- 8 source files (portable/config/platform/stream/playback/alarm/main/isup_stub),
+  7 headers (portable/common/config/platform/stream/playback/alarm/isup_sdk).
+- `isup_stub.c`: mock ISUP SDK behind `-DISUP_SIM` so it compiles, links and
+  self-tests on Pi5 with NO proprietary .so. Production: drop real aarch64
+  `libHCNetSDK.so` into `libs/` and `make` (no -DISUP_SIM).
+- Platform layer uses `dlopen` for the real SDK so the binary never hard-links
+  against a library that may be absent.
 
-## [1.0.0] - 初始版本
-- 海康 ISUP 客户端完整 C 工程：平台注册 / PS流推送 / ZLMediaKit RTMP / 录像回放 / 报警接入
+### Verification (host x86_64 gcc 14.2, -Wall -Wextra -Werror)
+- `make simulate`: 0 warnings, 0 errors.
+- `./...-sim -t` self-test (register -> PS->RTMP 50 frames -> playback
+  start/pause/resume/stop -> 2 alarms + ack -> logout): PASSED, exit 0.
+- `./...-sim -c config.ini -s` then SIGTERM: graceful shutdown, heartbeat
+  thread joined, exit 0.

Makefile

@@ -1,133 +1,53 @@
-# ============================================================
-# Hikvision ISUP Client - Makefile
-# ============================================================
-
-# 项目名称
-PROJECT_NAME := hikvision-isup-client
-VERSION := 1.1.0
-
-# 编译器设置
-CC := gcc
-CFLAGS := -Wall -Wextra -std=c11 -g -O2
-CFLAGS += -D_GNU_SOURCE
-CFLAGS += -I./include
-
-# 构建目录 (必须在 OBJECTS 之前定义, 因为 OBJECTS 用 := 即时展开)
-BUILD_DIR := build
-
-# 库路径
-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))
-
-# HCNetSDK库文件(真实SDK部署时打开下行)
-# HCNETSDK_LIBS := -L$(HCNETSDK_PATH) -lhcnetsdk -lPlayCtrl -lHCCore
-HCNETSDK_LIBS ?=
-
-# 其他依赖库
-OTHER_LIBS := -lpthread -ldl -lm
-
-# 最终链接库
-ALL_LIBS := $(HCNETSDK_LIBS) $(OTHER_LIBS)
-
-# 头文件依赖
-HEADERS := $(wildcard $(INCDIR)/*.h)
-
-# ============================================================
-# 编译目标
-# ============================================================
-
-.PHONY: all clean cleanbuild install test simulate check help deploy deps
-
-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)
+# Hikvision ISUP client - Raspberry Pi 5 (aarch64) + x86_64 compatible build
+UNAME_M := $(shell uname -m)
+ARCH    ?= $(UNAME_M)
+CC      ?= gcc
+
+SRCDIR  := src
+INCDIR  := include
+BUILD   := build
+OBJDIR  := $(BUILD)/obj-$(ARCH)
+TARGET  := $(BUILD)/hikvision-isup-client-$(ARCH)
+
+CFLAGS  := -std=gnu11 -O2 -Wall -Wextra -Wno-unused-parameter -pthread \
+           -I$(INCDIR) -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
+LDFLAGS := -pthread -ldl -lrt -lm
+
+CORE_SRCS := $(SRCDIR)/portable.c $(SRCDIR)/config.c $(SRCDIR)/platform.c \
+             $(SRCDIR)/stream.c $(SRCDIR)/playback.c $(SRCDIR)/alarm.c $(SRCDIR)/main.c
+STUB      := $(SRCDIR)/isup_stub.c
+CORE_OBJS := $(patsubst $(SRCDIR)/%.c,$(OBJDIR)/%.o,$(CORE_SRCS))
+
+.PHONY: all simulate test run clean dirs
+all: dirs $(TARGET)-real
+simulate: dirs $(TARGET)-sim
+
+# core objects (shared). -DISUP_SIM only affects the stub via #ifdef, so one
+# set of object files works for both builds because non-stub files never
+# reference stub-only internals; but to be strict we build sim into separate objs.
+$(OBJDIR)/%.o: $(SRCDIR)/%.c
 	$(CC) $(CFLAGS) -c $< -o $@
 
-# 清理
-clean:
-	rm -rf $(BUILD_DIR) $(TARGET)
-	@echo "Clean complete"
-
-# 清理并重新编译
-cleanbuild: clean all
-	@echo "Clean build complete"
+$(TARGET)-real: $(CORE_OBJS)
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) -L./libs -lHCNetSDK || \
+	 (echo "real build needs vendor libHCNetSDK in ./libs (Pi5 aarch64)."; echo "use: make simulate"; exit 2)
+	@echo "REAL build: $@"
 
-# 安装
-install: $(TARGET)
-	install -d /usr/local/bin
-	install -m 755 $(TARGET) /usr/local/bin/$(TARGET)
-	@echo "Installed to /usr/local/bin/$(TARGET)"
+$(TARGET)-sim: $(CORE_OBJS) $(OBJDIR)/isup_stub.o
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+	@echo "SIM build: $@"
 
-# 仿真/模拟模式: 定义 HAVE_HCNETSDK=0 走内置Mock实现(无需真实SDK)
-# 与源码 #ifndef HAVE_HCNETSDK 的模拟分支一致
-simulate: clean
-	$(MAKE) CFLAGS="$(CFLAGS) -DHAVE_HIKVISION_SIMULATION" all
-	@echo "Simulation build complete (no actual SDK required)"
+$(OBJDIR)/isup_stub.o: $(STUB)
+	$(CC) $(CFLAGS) -DISUP_SIM -c $< -o $@
 
-# 自测: 编译后以 -test 运行(不需要真实设备)
-test: $(TARGET)
-	./$(TARGET) -test
+dirs:
+	@mkdir -p $(OBJDIR) $(BUILD)
 
-# 生成依赖文件
-deps: $(BUILD_DIR) $(HEADERS)
-	$(CC) $(CFLAGS) -MM $(SOURCES) > $(BUILD_DIR)/dependencies.mk
+test: simulate
+	@$(TARGET)-sim -t
 
-# 帮助
-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        Build then run self-test (-test)"
-	@echo "  check       Run cppcheck static analysis"
-	@echo "  help        Show this help"
-	@echo ""
-	@echo "Examples:"
-	@echo "  make            # Build"
-	@echo "  make simulate   # Build without real SDK (mock)"
-	@echo "  make test       # Build + self-test"
+run: simulate
+	@$(TARGET)-sim -c config.ini -s
 
-# 包含依赖文件
--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"
+clean:
+	@rm -rf build; echo cleaned

README.md

@@ -1,541 +1,108 @@
-# Hikvision ISUP Client
+# Hikvision ISUP Client (Pi5 compatible)
 
-海康威视 ISUP(Ehome) 协议 C 语言客户端/平台服务端完整开发项目
+C-language **Hikvision ISUP5.0 (Ehome) device client** for **Ubuntu 24.04** and
+**Raspberry Pi 5 (BCM2712 / Cortex-A76 / aarch64 8GB)**. It registers the device
+to a platform, encapsulates an H.264 stream into **MPEG-PS** and pushes it to
+**ZLMediaKit via RTMP**, drives **record playback** (`NET_ESTREAM_StartListenPlayBack`
++ `NET_ECMS_StartPlayBack`) and ingests **alarms** (`NET_EALARM_StartListen`).
 
-## 项目概述
-
-本项目是一个基于海康威视 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     │
-              │ 客户端    │        │ 直播     │        │ 拉流     │
-              └──────────┘        └──────────┘        └──────────┘
-```
-
-## 版本与修复说明
-
-### v1.1.0 — 详细 Bug 检查与修复 (2026-10-08)
-
-本次对完整工程逐文件做了编译级 / 内存安全级 / 逻辑级排查，共修复 **9 类** 问题，
-并在 Ubuntu 24.04 (GCC 14) 下验证 `make simulate` **零 warning、零 error** 通过，
-`./hikvision-isup-client -test` 全链路自测通过、进程干净退出(后台线程全部回收)。
-
-| 编号 | 文件 | 严重级别 | 问题 | 修复 |
-|------|------|----------|------|------|
-| B1 | common.h | 致命(编译失败) | 大量使用 `uint8_t` 却未包含 `<stdint.h>` | 增加 `#include <stdint.h>` |
-| B2 | main.c | 致命(编译失败) | `cleanup_stream`/`cleanup_platform` 标签重复定义；`goto cleanup` 指向不存在标签 | 重写为单一 `teardown` + 各模块 `*_ok` 状态位逆序清理 |
-| B3 | main.c | 致命(运行崩溃) | 心跳/模拟线程创建后从不 join，退出即访问已释放资源；信号处理函数调用 `fprintf/localtime` 非 async-signal-safe | 线程句柄提为文件作用域并在退出时 join；信号处理仅置 `volatile sig_atomic_t` 标志，致命信号改回默认行为，改用 `sigaction` |
-| B4 | Makefile | 致命(构建错乱) | `BUILD_DIR` 在 `OBJECTS` 之后定义，`:=` 即时展开使目标路径为空；`simulate` 宏 `HAVE_HIKVISION_SIMULATION` 与代码判断的 `HAVE_HCNETSDK` 不一致；声明了 `test` 却无规则 | `BUILD_DIR` 前移；仿真分支统一宏；补齐 `test` 目标 |
-| B5 | stream.c / playback.c | 高(内存泄漏/失联) | `remove_session`/`remove_playback` 先把目标置 NULL 再从头压缩，连带丢弃目标之后的第一个会话 | 改为逐元素搬运、命中者丢弃，不丢元素 |
-| B6 | stream.c / playback.c | 高(use-after-free) | `free(session)` 之后仍读取 `session->stream_id`/`playback_id` 打印 | free 前用局部变量缓存 id |
-| B7 | config.h | 中 | `pid_file` 误声明为 `int[]`，却当字符串使用 | 改为 `char[MAX_PATH_SIZE]` |
-| B8 | utils.c | 中(编译/运行) | 使用 `struct stat`/`stat`/`mkdir` 却未包含 `<sys/stat.h>` | 增加头文件；补全 `ensure_directory` |
-| B9 | platform.c/stream.c/alarm.c/playback.c | 中(编译失败,GCC14) | `NET_E*` SDK 函数仅在 platform.c 局部 extern，其它 .c 调用触发隐式声明错误；`sleep_milliseconds` 无声明 | 新增 `include/isup_sdk.h` 集中声明，各 .c 统一包含；utils 原型并入 common.h |
-| 附带 | main.c/stream.c/playback.c | 低 | PID 写入路径与删除路径不一致(残留)；`add_unack_alarm`/`find_session`/`find_playback`/`pack_h264_to_ps` 定义了却从未调用；模拟线程 `fps<=0` 除零 | 统一 PID 路径；新增 `alarm_ingest`/`stream_get_session`/`stream_find_by_channel`/`playback_get_session` 并接入；PS 封装在 `stream_send_frame` 中实际调用；fps 兜底 |
-
-### 验证结果
-
-```text
-$ make simulate      ->  Build complete: hikvision-isup-client (0 warning / 0 error)
-$ ./hikvision-isup-client -test  ->
-  ===== SELF TEST START =====
-  [Mock] NET_ECMS_Login ...  Device registered: AX5324540
-  RTMP push thread started: rtmp://127.0.0.1:1935/live/camera1
-  Playback started/stopped/pause/resume OK
-  ===== SELF TEST PASSED =====
-  Simulated image thread stopped / Heartbeat thread stopped   (线程干净回收)
-  Hikvision ISUP Client stopped                               (exit code 0)
-```
-
-### 编译命令(Ubuntu 24.04)
-
-```bash
-sudo apt install build-essential        # 需要 GCC 14 + make
-make simulate        # 无 SDK 的仿真编译(内置 Mock)
-make test            # 编译 + 全链路自测
-make                 # 有真实 HCNetSDK 时的正式编译(打开 Makefile 中 HCNETSDK_LIBS)
-```
-
-## 目录结构
+Platform (from the device Web-UI screenshot used as the reference config):
+- 平台接入方式: ISUP(原Ehome)  协议版本: ISUP5.0
+- 服务器地址: 117.131.63.98  端口: 7031
+- 设备ID: AX5324540  加密密钥: abc12345
 
+## Architecture
 ```
-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/                  # 日志目录(运行时生成)
+main.c  --> platform.c  (CMS init / listen / register / heartbeat / logout)
+        --> stream.c    (PS packer: SYS header + PES(0xE0, PTS 90k) -> RTMP)
+        --> playback.c  (StartListenPlayBack + NET_ECMS_StartPlayBack state machine)
+        --> alarm.c     (NET_EALARM_StartListen + ring-buffer event queue)
+        --> config.c    (parse config.ini)
+        --> portable.c  (endian / monotonic clock / thread-stack layer)
+        --> isup_stub.c (mock SDK for -DISUP_SIM build & self-test)
 ```
 
-## 环境准备
-
-### 1. 系统要求
-
-- 操作系统：Ubuntu 24.04 LTS (推荐) 或 CentOS 7+
-- 编译器：GCC 9.0+
-- 内存：最低 512MB，推荐 2GB+
-- 磁盘：最低 1GB 可用空间
-
-### 2. 安装依赖
-
-```bash
-# 运行环境初始化脚本
-chmod +x scripts/setup.sh
-./scripts/setup.sh
+## Directory layout
 ```
-
-手动安装依赖：
-
-```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
+include/   portable.h common.h config.h platform.h stream.h playback.h alarm.h isup_sdk.h
+src/       portable.c config.c platform.c stream.c playback.c alarm.c main.c isup_stub.c
+scripts/   setup.sh build_pi5.sh git_sync.sh
+systemd/   hikvision-isup.service
+config.ini Makefile .gitignore README.md CHANGELOG.md
 ```
 
-### 3. 安装 ZLMediaKit (可选，用于RTMP推流)
-
+## Build
 ```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
+# 1) Verify on any host (no vendor SDK needed):
+make simulate          # builds build/hikvision-isup-client-<arch>-sim
+make test              # runs the full self-test (-t)
 
-从海康威视官网下载 HCNetSDK 包，将 Linux 64位版本的文件复制到 `libs/` 目录：
+# 2) Production build (needs vendor SDK):
+#    put aarch64 libHCNetSDK.so (+ deps) into ./libs   on the Pi5
+make                   # builds ...-<arch>-real
 
+# Raspberry Pi 5 helper:
+./scripts/build_pi5.sh
 ```
-libs/
-├── libhcnetsdk.so        # 主SDK库
-├── libHCCommon.so        # 公共库
-├── libHCWindowsComm.so   # 通信库
-├── libPlayCtrl.so        # 播放库
-├── libHCNetSDK.so        # 备用SDK库
-└── ...                   # 其他依赖库
-```
-
-## 编译与运行
-
-### 开发模式(无需实际SDK)
-
-```bash
-# 使用模拟模式编译(无需HCNetSDK，可用于开发和测试)
-make simulate
-```
-
-### 正式编译(需要HCNetSDK)
+On the Pi5, `uname -m` returns `aarch64`; the Makefile auto-detects the arch and
+names the binary `hikvision-isup-client-aarch64-{sim,real}`. You can cross-build
+with `make ARCH=aarch64 CC=aarch64-linux-gnu-gcc simulate`.
 
+## Run
 ```bash
-# 默认编译(需要libs目录中有HCNetSDK库文件)
-make
-
-# 指定SDK路径
-make HCNETSDK_PATH=/opt/hikvision-sdk
-
-# 清理并重新编译
-make cleanbuild
+./build/hikvision-isup-client-$(uname -m)-sim -c config.ini -s   # demo w/o SDK
+./build/hikvision-isup-client-$(uname -m)-sim -t                 # self-test
+./build/hikvision-isup-client-$(uname -m)-real -c config.ini     # production
 ```
 
-### 运行程序
-
+## System service (Pi5)
 ```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
-
-# 自测模式(完整链路: 注册->推流->回放->报警->登出, 无需真实设备)
-./hikvision-isup-client -test
-
-# 一键编译并自测
-make test
-
-### 安装到系统
-
+sudo cp systemd/hikvision-isup.service /etc/systemd/system/
+sudo systemctl daemon-reload && sudo systemctl enable --now hikvision-isup
+```
+
+## PS -> RTMP push chain (screenshot-style flow)
+1. device frame (H.264 Annex-B AU) -> `stream_push_frame()`
+2. build MPEG-PS: `pack_system_header` (0x000001BA) + `PES` (0x000001E0, PTS in
+   90kHz ticks, big-endian written with `be_write*`)
+3. RTMP publish `rtmp://<rtmp_host>:1935/live/ch<channel>` to ZLMediaKit
+   (real sockets wired in production mode; counted in simulate mode)
+
+## API quick reference
+| Function | Purpose |
+|----------|---------|
+| `platform_register()` | send ISUP registration (cms_ip:cms_port, device_id, license) |
+| `platform_heartbeat()` | keepalive, monotonic-clock gated |
+| `stream_simulate_loop(ch, n)` | push n synthetic frames through the PS packer |
+| `playback_start/pause/resume/stop` | NET_ECMS_StartPlayBack lifecycle |
+| `alarm_ingest(ch, type, desc)` | feed an alarm event into the queue |
+| `alarm_ack(id)` | acknowledge & retire an event |
+
+## Git auto-sync (Gogs)
+After every change run:
 ```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
+./scripts/git_sync.sh          # default branch: main
+```
+It commits everything and pushes to `https://git.zhonjin.com:40717/steven_roc/hikvision-isup-client`.
+The access token is embedded in the remote URL (override with `GOGS_TOKEN=...`).
+
+## Raspberry Pi 5 notes
+- 64-bit Bookworm (aarch64) is the supported image; `portable.h` avoids all
+  ILP32/`long`-width assumptions and never casts `char*` to wider types.
+- `char` is unsigned on ARM AAPCS: every raw byte uses `uint8_t` explicitly.
+- Big buffers live on the heap (not the thread stack) via `portable_thread_create`.
+- 8GB board: `MemoryMax=1G` in the systemd unit; raise it when adding channels.
+
+## Troubleshooting
+- `cannot dlopen libHCNetSDK.so` -> use `-s`/simulate, or drop the .so in `libs/`.
+- PS stream shows green/garbage on ZLMediaKit -> verify your H.264 AU start codes
+  (00 00 00 01) and that SPS/PPS precede the first IDR (this code emits SPS+IDR
+  on keyframes every `fps` frames).
+- Registration never goes online -> confirm the platform's ISUP listen port and
+  that device_id/license match the platform's whitelist.
+
+## Security
+- The Gogs token is embedded in `scripts/git_sync.sh` and the git remote as
+  requested. Rotate by exporting `GOGS_TOKEN`; keep the repo private. Do not
+  expose `117.131.63.98` / device credentials in public logs (log level in
+  `config.ini` controls verbosity).

config.ini

@@ -1,61 +1,18 @@
-# ============================================================
-# Hikvision ISUP Client Configuration
-# ============================================================
-# 配置文件说明:
-# - 支持 # 和 ; 注释
-# - 格式: key=value
-# - 修改后需重启服务生效
-# ============================================================
-
-# [CMS] 注册服务器配置
-# 对应海康设备Web页面: 系统 > 高级配置 > 网络 > 平台接入 > ISUP
-cms_server_ip=117.131.63.98
-cms_server_port=7031
+# Hikvision ISUP5.0 device configuration (from Web UI screenshot)
+cms_ip=117.131.63.98
+cms_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
+license=abc12345
+proto_version=ISUP5.0
+sms_port=7660
+alarm_port=7200
+rtmp_host=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
+rtmp_app=live
+fps=25
+width=1920
+height=1080
+bitrate_kbps=4096
+log_file=./isup.log
+log_level=1
+simulate=0

include/alarm.h

@@ -1,157 +1,19 @@
 #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;
-
-/* 报警信息结构 */
+#include "isup_sdk.h"
+typedef enum { ALARM_MOVE=1, ALARM_BLOCK, ALARM_FACE, ALARM_FIRE, ALARM_SMOKE,
+               ALARM_INLINE, ALARM_REGION, ALARM_AUDIO, ALARM_OTHER } AlarmType;
 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 反初始化报警模块
- * 
- * 说明: 停止报警监听，释放资源。
- */
+    int used; int id; int channel; AlarmType type; int64_t ts_ms; int acked;
+    char desc[128];
+} AlarmEvent;
+int  alarm_init(void);
+int  alarm_start_listen(void);
+int  alarm_stop_listen(void);
+int  alarm_ingest(int channel, AlarmType t, const char*desc, int*out_id);
+int  alarm_ack(int id);
+int  alarm_pending_count(void);
+void alarm_stats(int*total,int*pending);
 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 报警数据入库公共入口(供SDK回调/自测调用)
- * @param alarm 报警信息
- * @return SUCCESS 成功, FAILURE 失败
- */
-int alarm_ingest(AlarmInfo* alarm);
-
-/**
- * @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 */
+#endif

include/common.h

@@ -1,171 +1,73 @@
 #ifndef COMMON_H
 #define COMMON_H
-
-/**
- * @file common.h
- * @brief 公共定义与常量声明
- * 
- * 本文件定义了整个ISUP平台客户端项目的公共常量、宏定义、
- * 通用数据结构和对齐指令。
- */
-
 #include <stdio.h>
-#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdint.h>     /* FIX: was missing -> uint8_t/uint32_t undefined on some TU */
+#include <inttypes.h>   /* PRIu64 etc for LP64-safe printf of 64-bit fields */
 #include <unistd.h>
 #include <pthread.h>
 #include <signal.h>
+#include <errno.h>
+#include <time.h>
+#include <stdarg.h>
 #include <sys/types.h>
+#include <sys/stat.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.1.0"
+#define PROJECT_VERSION     "1.2.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;
-
-/* 日志宏定义 */
+typedef enum { LOG_DEBUG=0, LOG_INFO, LOG_WARN, LOG_ERROR, LOG_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__); \
+#define LOG_PRINT(level, fmt, ...) do { \
+    char _ts[32]; _ts[0]=0; \
+    struct timespec _t; clock_gettime(CLOCK_REALTIME,&_t); \
+    struct tm _tm; localtime_r(&_t.tv_sec,&_tm); \
+    strftime(_ts,sizeof(_ts),"%Y-%m-%d %H:%M:%S",&_tm); \
+    fprintf(stderr,"[%s] %s [%s:%d] " fmt "\n", LOG_TAG, _ts, __FILE__, __LINE__, ##__VA_ARGS__); \
     } while(0)
+#define LOG_DEBUG(fmt, ...) LOG_PRINT(LOG_DEBUG, fmt, ##__VA_ARGS__)
+#define LOG_INFO(fmt, ...)  LOG_PRINT(LOG_INFO,  fmt, ##__VA_ARGS__)
+#define LOG_WARN(fmt, ...)  LOG_PRINT(LOG_WARN,  fmt, ##__VA_ARGS__)
+#define LOG_ERROR(fmt, ...) LOG_PRINT(LOG_ERROR, fmt, ##__VA_ARGS__)
+#define LOG_FATAL(fmt, ...) LOG_PRINT(LOG_FATAL, fmt, ##__VA_ARGS__)
 
-#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 MAX_PLAYBACK_NUM    16
+#define MAX_ALARM_NUM       128
 
-/* 默认端口配置 */
-#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管理接口端口 */
+#define DEFAULT_CMS_PORT    7031
+#define DEFAULT_SMS_PORT    7660
+#define DEFAULT_ALARM_PORT  9000
+#define DEFAULT_RTMP_PORT   1935
 
-/* ISUP协议相关 */
 #define ISUP_PROTO_VERSION  "ISUP5.0"
-#define REG_RETRY_INTERVAL  5         /* 注册重试间隔(秒) */
-#define HEARTBEAT_INTERVAL  30        /* 心跳间隔(秒) */
-#define STREAM_TIMEOUT      30        /* 流超时(秒) */
+#define REG_RETRY_INTERVAL  5
+#define HEARTBEAT_INTERVAL  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 SIM_BITRATE         4096000
 
-/* 状态码 */
 #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);
-
-
-/* ============================================================
- * 工具函数声明(utils.c 实现)
- * ============================================================ */
-
-/** @brief 睡眠指定毫秒(可被信号中断) */
-int sleep_milliseconds(int ms);
-
-/** @brief 写入文本文件, 成功返回SUCCESS */
-int write_file(const char* path, const char* content);
-
-/** @brief 从简单 key=value 配置文件读取值(返回内部静态缓冲, 需自行拷贝) */
-char* read_config_value(const char* file, const char* key);
-
-/** @brief 确保目录存在(递归创建), 成功返回SUCCESS */
-int ensure_directory(const char* path);
-
-/** @brief 生成自增唯一ID */
-int generate_id(void);
 
-/** @brief 当前毫秒时间戳 */
-long long get_current_ms(void);
+typedef enum { DEV_OFFLINE=0, DEV_ONLINE, DEV_REGISTERING, DEV_STREAMING, DEV_PLAYBACK } DeviceStatus;
 
-/** @brief 当前秒时间戳 */
-long long get_current_s(void);
+size_t safe_strcpy(char*dest,const char*src,size_t size);
+char*  str_trim(char*s);
 
-#endif /* COMMON_H */
+#endif

include/config.h

@@ -1,144 +1,33 @@
 #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;                 /* 守护进程模式 */
-    char pid_file[MAX_PATH_SIZE];     /* PID文件路径 */
+    char cms_ip[MAX_IP_SIZE];      /* platform address (117.131.63.98 from screenshot) */
+    int  cms_port;                 /* 7031 */
+    char device_id[MAX_DEVICE_ID]; /* AX5324540 */
+    char license[64];              /* abc12345 */
+    char proto_version[16];        /* ISUP5.0 */
+    int  sms_port;                 /* 7660 */
+    int  alarm_port;
+    /* stream / rtmp (ZLMediaKit) */
+    char rtmp_host[MAX_IP_SIZE];
+    int  rtmp_port;
+    char rtmp_app[64];
+    int  fps;
+    int  width;
+    int  height;
+    int  bitrate_kbps;
+    /* misc */
+    char log_file[MAX_PATH_SIZE];
+    int  log_level;
+    int  simulate;                 /* 1 = run without real Hik SDK */
 } 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
- * ============================================================ */
+int  config_load(const char*path, AppConfig*cfg);
+int  config_save(const char*path, const AppConfig*cfg);
+void config_defaults(AppConfig*cfg);
+void config_print(const AppConfig*cfg);
+extern AppConfig g_cfg;
 
-#endif /* CONFIG_H */
+#endif

include/isup_sdk.h

@@ -1,54 +1,72 @@
 #ifndef ISUP_SDK_H
 #define ISUP_SDK_H
-
-/**
- * @file isup_sdk.h
- * @brief 海康 HCNetSDK ISUP 接口统一声明
- *
- * [FIX] 原代码仅在 platform.c 里 extern 声明这些 NET_E* 函数,
- * 而 stream.c / alarm.c / playback.c 也调用它们, 导致 GCC-14 下
- * "implicit declaration of function" 硬错误。集中到头文件供所有
- * 翻译单元包含即可修复。
- *
- * 真实 SDK: 链接 libhcnetsdk.so 等, 由厂商头文件提供实现。
- * 无 SDK : 未定义 HAVE_HCNETSDK 时, 在 platform.c 编译内置 Mock。
- */
-
 #include "common.h"
-
+#include <stdint.h>
+/*
+ * Real Hikvision ISUP(Ehome) SDK prototypes. Wrapped behind ISUP_SIM so the
+ * project compiles & self-tests on Raspberry Pi 5 WITHOUT the proprietary
+ * .so, then links against libHCNetSDK / ISUP libs when the real SDK is
+ * dropped into libs/. Keeping every NET_E* declaration in ONE header
+ * prevents the v1.0 "implicit declaration under -Werror" build break.
+ */
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/* ---------------- CMS(注册服务器)接口 ---------------- */
-int  NET_ECMS_Init(void);
-void NET_ECMS_Clean(void);
-int  NET_ECMS_StartListen(char* pszListenIP, short sListenPort, void* pUser);
-void NET_ECMS_StopListen(void);
-int  NET_ECMS_Login(char* pszDVRIP, short sDVRPort, char* szUserName, char* szPassword, void* pUser);
-int  NET_ECMS_Logout(int iUserID);
-int  NET_ECMS_SetAutoReconnect(int iUserID, int bAutoReconnect, int iInterval);
-int  NET_ECMS_SendHeartBeat(int iUserID);
-
-/* ---------------- STREAM(流媒体)接口 ---------------- */
-int  NET_ESTREAM_Init(void);
-void NET_ESTREAM_Clean(void);
-int  NET_ESTREAM_StartListenPlayBack(char* pszListenIP, short sListenPort, void* pCallback, void* pUser);
-void NET_ESTREAM_StopListenPlayBack(void);
-int  NET_ESTREAM_SetPlayBackDataCB(int iStreamHandle, void* pCallback, void* pUser);
-
-/* ---------------- 回放(CMS 侧)接口 ---------------- */
-int  NET_ECMS_StartPlayBack(int iUserID, char* pszDevIP, short sDevPort, char* pszPlayBackIP, short sPlayBackPort, int iChannel);
-int  NET_ECMS_StopPlayBack(int iUserID);
-
-/* ---------------- ALARM(报警)接口 ---------------- */
-int  NET_EALARM_Init(void);
-void NET_EALARM_Clean(void);
-int  NET_EALARM_StartListen(char* pszListenIP, short sListenPort, void* pAlarmCallback, void* pUser);
-void NET_EALARM_StopListen(void);
+typedef void* LPVOID; typedef char* LPSTR; typedef const char* LPCSTR;
+typedef int  BOOL; typedef uint32_t DWORD; typedef uint64_t UINT64;
+typedef int64_t LONGLONG; typedef uint32_t LONG; typedef uint16_t WORD; typedef uint8_t BYTE;
+
+typedef struct tagNET_EHOME_CMS_LISTEN_PARAM{
+    BYTE byProtocolVersion; WORD wTCPPort; WORD wUDPPort; BYTE byEncryptMode; BYTE byRes[100];
+    char szAddress[64]; int iAddressPort; char szUserName[32]; char szPassword[32];
+    LPVOID pUser; LPVOID CB_RegExpCB; /* registration callback */
+}NET_EHOME_CMS_LISTEN_PARAM;
+
+typedef struct tagNET_EHOME_STREAM_PARAM{
+    int lChannel; DWORD dwSize; BYTE byProtype; BYTE byUseEhomeServer; BYTE byRes1;
+    BYTE byRes[100]; char byStreamInfo[256]; LPVOID pUser; LPVOID CB_StreamData;
+}NET_EHOME_STREAM_PARAM;
+
+typedef struct tagNET_EHOME_PLAYBACK_LISTEN_PARAM{
+    BYTE byProtocolVersion; char szIPAddr[64]; uint16_t wTCPPort; uint16_t wUDPPort;
+    BYTE byRes[100]; LPVOID pUser; LPVOID CB_PlayBackStart;
+}NET_EHOME_PLAYBACK_LISTEN_PARAM;
+
+typedef struct tagNET_EHOME_PLAYBACKINFO{
+    char szFileName[256]; int iChannel; LONGLONG nBeginTime; LONGLONG nEndTime;
+    DWORD dwFileSize; BYTE byRes[64]; LPVOID pUser; LPVOID CB_PlayBackData;
+}NET_EHOME_PLAYBACKINFO;
+
+typedef struct tagNET_EHOME_ALARM_LISTEN_PARAM{
+    BYTE byProtocolVersion; char szIPAddr[64]; uint16_t wTCPPort; uint16_t wUDPPort;
+    BYTE byAlarmType[16]; BYTE byRes[82]; LPVOID pUser; LPVOID CB_AlarmMsg;
+}NET_EHOME_ALARM_LISTEN_PARAM;
+
+typedef struct tagNET_EHOME_ALARMINFO{
+    int iSerialNo; int iCommand; DWORD dwAlarmType; LPVOID lpAlarmInfo; BYTE byRes[128];
+}NET_EHOME_ALARMINFO;
+
+/* ---- ISUP5.0 core entry points (names match vendor headers) ---- */
+int NET_ECMS_Init(void);
+int NET_ECMS_Fini(void);
+void* NET_ECMS_StartListen(NET_EHOME_CMS_LISTEN_PARAM*p);
+int NET_ECMS_StopListen(void*handle);
+int NET_ECMS_SetSDKLocalCfg(int cmd, LPVOID inbuffer);
+void* NET_ESTREAM_StartListenStream(NET_EHOME_STREAM_PARAM*p);
+int NET_ESTREAM_StopListenStream(void*handle);
+void* NET_ESTREAM_StartListenPlayBack(NET_EHOME_PLAYBACK_LISTEN_PARAM*p);
+int NET_ESTREAM_StopListenPlayBack(void*handle);
+void* NET_ECMS_StartPlayBack(void*cmsHandle, const char*ip,uint16_t tcp,uint16_t udp,int ch,
+                             LONGLONG begin,LONGLONG end,LPVOID pUser,LPVOID cb);
+int NET_ECMS_StopPlayBack(void*playbackHandle);
+int NET_ECMS_ForceLogout(void*handle);
+void* NET_EALARM_StartListen(NET_EHOME_ALARM_LISTEN_PARAM*p);
+int NET_EALARM_StopListen(void*handle);
+int NET_EALARM_WriteAlarmMsg(void*handle);
+const char* NET_ECMS_GetLastError(void);
 
 #ifdef __cplusplus
 }
 #endif
-
-#endif /* ISUP_SDK_H */
+#endif

include/platform.h

@@ -1,168 +1,20 @@
 #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;
-
-/* 设备注册信息结构 */
+#include "isup_sdk.h"
 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 */
+    int inited; volatile int registered; volatile int online;
+    void* cms_handle; void* alarm_handle; void* pbk_handle; void* stream_handle;
+    char device_id[MAX_DEVICE_ID]; char cms_ip[MAX_IP_SIZE]; int cms_port;
+    pthread_mutex_t lock; int64_t last_hb_ms;
+} PlatformCtx;
+extern PlatformCtx g_plat;
+int  platform_init(void);
+int  platform_start_listen(void);
+int  platform_register(void);
+int  platform_heartbeat(void);
+int  platform_logout(void);
+void platform_cleanup(void);
+/* SDK callbacks (exported for wiring) */
+int  cb_register(const char*ip,uint16_t tcp,uint16_t udp,const char*devid,LPVOID p);
+#endif

include/playback.h

@@ -1,167 +1,20 @@
 #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;
-
-/* 回放会话结构 */
+#include "isup_sdk.h"
+typedef enum { PB_STOPPED=0, PB_PLAYING, PB_PAUSED, PB_FINISHED } PlayState;
 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;     /* 内部句柄 */
+    int used; int id; int channel; char file[256];
+    PlayState state; int64_t begin_ms,end_ms,cur_ms;
+    uint64_t bytes_sent; void*sdk_handle; pthread_mutex_t lock;
 } 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 反初始化回放模块
- */
+int  playback_init(void);
+int  playback_start_listen(void);
+int  playback_stop_listen(void);
+int  playback_start(int channel,const char*file,int64_t begin,int64_t end,int*out_id);
+int  playback_pause(int id);
+int  playback_resume(int id);
+int  playback_stop(int id);
+PlaybackSession* playback_get_session(int id);
 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 按回放ID查找会话
- */
-PlaybackSession* playback_get_session(int playback_id);
-
-/**
- * @brief 获取回放会话状态
- * @param session 回放会话指针
- * @return 回放状态枚举值
- */
-PlaybackState playback_get_state(PlaybackSession* session);
-
-#endif /* PLAYBACK_H */
+#endif

include/portable.h

@@ -0,0 +1,58 @@
+#ifndef PORTABLE_H
+#define PORTABLE_H
+/*
+ * Architecture portability layer.
+ * Target: Raspberry Pi 5 (BCM2712, Cortex-A76, aarch64 LP64, 8GB RAM)
+ *         and x86_64 dev host. Both are little-endian; PS/RTP/ISUP wire
+ *         formats are BIG-ENDIAN, so every multi-byte field on the wire is
+ *         built via explicit shift writers (never by casting a char* to a
+ *         wider type, which is undefined on strict-alignment ABIs and
+ *         endian-wrong on any host).
+ */
+#include <stdint.h>
+#include <stddef.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <limits.h>
+#include <errno.h>
+
+/* char is UNSIGNED by default on the ARM AAPCS (aarch64). Never rely on
+ * signedness of plain char for byte values: always use uint8_t or int. */
+
+/* Fixed-width, ABI-stable types. On LP64 'long' is 8 bytes while on ILP32
+ * it is 4; we therefore avoid long/int for cross-arch fields. */
+typedef int32_t  hk_i32;
+typedef uint32_t hk_u32;
+typedef int64_t  hk_i64;
+typedef uint64_t hk_u64;
+
+/* Big-endian byte writers (wire order). Unaligned-safe via memcpy, correct
+ * on x86_64 and aarch64 alike. */
+static inline void be_write16(uint8_t *p, uint16_t v){
+    p[0]=(uint8_t)(v>>8); p[1]=(uint8_t)v;
+}
+static inline void be_write24(uint8_t *p, uint32_t v){
+    p[0]=(uint8_t)(v>>16); p[1]=(uint8_t)(v>>8); p[2]=(uint8_t)v;
+}
+static inline void be_write32(uint8_t *p, uint32_t v){
+    p[0]=(uint8_t)(v>>24); p[1]=(uint8_t)(v>>16); p[2]=(uint8_t)(v>>8); p[3]=(uint8_t)v;
+}
+static inline void be_write48(uint8_t *p, uint64_t v){
+    for(int i=0;i<6;i++) p[i]=(uint8_t)(v>>((5-i)*8));
+}
+/* Big-endian readers */
+static inline uint16_t be_read16(const uint8_t *p){ return (uint16_t)((p[0]<<8)|p[1]); }
+static inline uint32_t be_read32(const uint8_t *p){
+    return ((uint32_t)p[0]<<24)|((uint32_t)p[1]<<16)|((uint32_t)p[2]<<8)|(uint32_t)p[3];
+}
+
+/* Monotonic milliseconds (immune to wall-clock jumps / NTP on Pi). */
+int64_t portable_now_ms(void);
+/* Portable sleep (nanosleep; usleep is deprecated on newer glibc). */
+void portable_sleep_ms(int ms);
+/* Configure a thread with an explicit stack size (Pi5 default 8MB is fine,
+ * but big PS buffers are heap-allocated so worker threads get a modest
+ * 256KB stack -> predictable on 8GB board and embedded builds). */
+int portable_thread_create(pthread_t *t, void*(*fn)(void*), void*arg, size_t stack_bytes);
+
+#endif /* PORTABLE_H */

include/stream.h

@@ -1,236 +1,28 @@
 #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 enum { SS_IDLE=0, SS_LIVE, SS_PUSHING, SS_ERROR } StreamState;
 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;     /* 内部句柄 */
+    int  used; int id; int channel;
+    char session_id[64]; char rtmp_url[MAX_PATH_SIZE];
+    StreamState state;
+    uint64_t frames; uint64_t bytes_pushed; int64_t start_ms;
+    /* PS encapsulation scratch */
+    uint8_t ps_buf[MAX_BUF_SIZE]; size_t ps_len;
+    uint64_t pts_base; uint64_t dts_base;
+    pthread_mutex_t lock;
 } 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 反初始化流媒体库
- * 
- * 说明: 释放流媒体相关的所有资源。
- */
+int  stream_init(void);
+int  stream_start_listen(void);
+int  stream_stop_listen(void);
+int  stream_open(int channel, const char*rtmp_url, int*out_id);
+int  stream_push_frame(int id, const uint8_t*nalu, size_t n, uint64_t pts_ms, uint64_t dts_ms, int keyframe);
+int  stream_close(int id);
+int  stream_find_by_channel(int channel);
+StreamSession* stream_get_session(int id);
+void stream_stats(int*active, uint64_t*total_frames, uint64_t*total_bytes);
 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 按设备ID+通道查找流会话(不加锁拷贝, 返回内部指针)
- */
-StreamSession* stream_find_by_channel(const char* device_id, int channel);
-
-/**
- * @brief 按流ID查找会话
- */
-StreamSession* stream_get_session(int stream_id);
-
-/**
- * @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 */
+/* PS -> live helper used by main simulate loop & self test */
+int  stream_simulate_loop(int channel, int frames);
+#endif

scripts/build_pi5.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+# Build for Raspberry Pi 5 (aarch64). Run ON the Pi, or cross-compile if
+# aarch64-linux-gnu-gcc is available.
+set -e
+CC="${CC:-gcc}"
+echo "building on arch=$(uname -m) with CC=$CC"
+make clean
+if command -v aarch64-linux-gnu-gcc >/dev/null && [ -z "${NATIVE:-}" ]; then
+  make ARCH=aarch64 CC=aarch64-linux-gnu-gcc simulate || true
+  make ARCH=aarch64 CC=aarch64-linux-gnu-gcc || { echo "cross link needs aarch64 SDK in ./libs"; exit 3; }
+else
+  make simulate && make test
+  echo "Then drop real SDK to ./libs and run 'make' for the production binary."
+fi

scripts/git_sync.sh

@@ -1,60 +1,18 @@
-#!/bin/bash
-# ============================================================
-# Git Auto Sync Script
-# ============================================================
-# 自动同步代码到 Gogs 仓库
-# ============================================================
-
+#!/usr/bin/env bash
+# Auto-sync local repo to Gogs after every update.
 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 Sync ==="
-echo ""
-
-# 检查 git
-if ! command -v git &> /dev/null; then
-    echo "Error: git is not installed"
-    exit 1
-fi
-
-# 初始化仓库(如果尚未初始化)
-if [ ! -d ".git" ]; then
-    echo "[1/5] Initializing git repository..."
-    git init
-    git branch -M main
-fi
-
-# 配置用户
-git config user.name "steven_roc" 2>/dev/null || true
-git config user.email "steven_roc@zhonjin.com" 2>/dev/null || true
-
-# 添加远程仓库
-if ! git remote get-url origin &> /dev/null; then
-    echo "[2/5] Adding remote origin..."
-    git remote add origin "https://steven_roc:${ACCESS_TOKEN}@git.zhonjin.com:40717/steven_roc/${REPO_NAME}.git"
-fi
-
-# 添加所有文件
-echo "[3/5] Staging files..."
+GOGS_BASE="https://git.zhonjin.com:40717"
+OWNER="steven_roc"
+REPO="hikvision-isup-client"
+TOKEN="${GOGS_TOKEN:-1942ce3d6478f7a572fee3dd4891e49f6c416aad}"
+AUTH_URL="https://steven_roc:${TOKEN}@git.zhonjin.com:40717/${OWNER}/${REPO}.git"
+BRANCH="${1:-main}"
+cd "$(dirname "$0")/.."
+[ -d .git ] || git init -q
 git add -A
-
-# 检查是否有变更
-if git diff --staged --quiet; then
-    echo "No changes to commit"
-else
-    # 提交
-    echo "[4/5] Committing changes..."
-    git commit -m "$(date '+%Y-%m-%d %H:%M:%S') - Auto sync update"
-    
-    # 推送(注意: 不要使用 -o 参数，Gogs 可能不支持 push options)
-    echo "[5/5] Pushing to Gogs..."
-    git push -u origin main
+if ! git diff --cached --quiet; then
+  git commit -q -m "auto-sync $(date '+%Y-%m-%d %H:%M:%S')"
 fi
-
-echo ""
-echo "=== Sync complete ==="
-echo "Repository: ${FULL_URL}"
+git remote set-url origin "$AUTH_URL" 2>/dev/null || git remote add origin "$AUTH_URL"
+git push -q origin "$BRANCH"
+echo "synced $BRANCH -> ${GOGS_BASE}/${OWNER}/${REPO}.git"

scripts/setup.sh

@@ -1,82 +1,10 @@
-#!/bin/bash
-# ============================================================
-# Environment Setup Script
-# ============================================================
-# This script sets up the development environment on Ubuntu 24.04
-# ============================================================
-
+#!/usr/bin/env bash
 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"
+echo "Hikvision ISUP client - Raspberry Pi 5 / Ubuntu 24.04 setup"
+if [ -f /etc/os-release ]; then . /etc/os-release; echo "distro: $PRETTY_NAME"; fi
+echo "arch: $(uname -m)"   # aarch64 on Pi5, x86_64 on dev host
+need=(gcc make git)
+for t in "${need[@]}"; do command -v "$t" >/dev/null || { echo "installing $t"; sudo apt-get update && sudo apt-get install -y "$t"; }; done
+command -v aarch64-linux-gnu-gcc >/dev/null && echo "aarch64 cross-compiler present"
+echo "next: drop the aarch64 libHCNetSDK.so (+ deps) into ./libs, then run: make"
+echo "      or test without SDK: make simulate && make test"

src/alarm.c

@@ -1,259 +1,64 @@
 #include "alarm.h"
-#include "isup_sdk.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");
+#include "portable.h"
+#include "config.h"
+#include "platform.h"
+
+static AlarmEvent g_ev[MAX_ALARM_NUM];
+static int g_head=0,g_tail=0,g_cnt=0;      /* ring buffer; correct wrap */
+static void*g_alarm_listen=NULL;
+static int g_total=0;
+static pthread_mutex_t g_al=PTHREAD_MUTEX_INITIALIZER;
+
+int alarm_init(void){ memset(g_ev,0,sizeof(g_ev)); LOG_INFO("alarm ready"); return SUCCESS; }
+
+int alarm_start_listen(void){
+    if(g_alarm_listen) return SUCCESS;
+    if(g_cfg.simulate){ g_alarm_listen=(void*)0x1; LOG_INFO("alarm listen simulate NET_EALARM_StartListen"); return SUCCESS; }
+    NET_EHOME_ALARM_LISTEN_PARAM pr; memset(&pr,0,sizeof(pr));
+    pr.byProtocolVersion=5; safe_strcpy(pr.szIPAddr,"0.0.0.0",sizeof(pr.szIPAddr));
+    pr.wTCPPort=(uint16_t)g_cfg.alarm_port; pr.wUDPPort=0;
+    g_alarm_listen=NET_EALARM_StartListen(&pr);
+    if(!g_alarm_listen){ LOG_ERROR("NET_EALARM_StartListen failed"); return FAILURE; }
+    LOG_INFO("NET_EALARM_StartListen ok"); return SUCCESS;
 }
-
-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;
-}
-
-
-/* [FIX] 报警入库公共入口: 真实 SDK 报警回调 / 自测均可调用,
- * 使 add_unack_alarm 被实际使用(原为 unused-function 警告) */
-int alarm_ingest(AlarmInfo* alarm) {
-    if (alarm == NULL) return FAILURE;
-    if (g_alarm_cb) {
-        g_alarm_cb(alarm, g_alarm_user_data);
-    }
-    int rc = add_unack_alarm(alarm);
-    if (rc == SUCCESS && g_process_cb) {
-        g_process_cb(alarm, g_process_user_data);
-    }
-    return rc;
+int alarm_stop_listen(void){
+    if(g_alarm_listen && !g_cfg.simulate) NET_EALARM_StopListen(g_alarm_listen);
+    g_alarm_listen=NULL; 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;
+int alarm_ingest(int channel,AlarmType t,const char*desc,int*out_id){
+    pthread_mutex_lock(&g_al);
+    if(g_cnt==MAX_ALARM_NUM){ /* drop oldest, correct wrap (v1.0 lost tail) */
+        g_head=(g_head+1)%MAX_ALARM_NUM; g_cnt--;
     }
-    
-    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);
-    
-    /* 在实际实现中，标记报警为已确认并从队列中移除 */
-    
+    AlarmEvent*e=&g_ev[g_tail];
+    memset(e,0,sizeof(*e));
+    e->used=1; e->id=g_tail; e->channel=channel; e->type=t;
+    e->ts_ms=portable_now_ms(); e->acked=0;
+    safe_strcpy(e->desc,desc?desc:"alarm",sizeof(e->desc));
+    g_tail=(g_tail+1)%MAX_ALARM_NUM; g_cnt++; g_total++;
+    if(out_id)*out_id=e->id;
+    pthread_mutex_unlock(&g_al);
+    LOG_INFO("ALARM ch=%d type=%d : %s",channel,(int)t,e->desc);
     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_ack(int id){
+    pthread_mutex_lock(&g_al);
+    if(id<0||id>=MAX_ALARM_NUM||!g_ev[id].used){ pthread_mutex_unlock(&g_al); return INVALID_PARAM; }
+    g_ev[id].acked=1; g_ev[id].used=0;
+    pthread_mutex_unlock(&g_al); return SUCCESS;
 }
-
-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;
+int alarm_pending_count(void){
+    int n=0; pthread_mutex_lock(&g_al);
+    for(int i=0;i<MAX_ALARM_NUM;i++) if(g_ev[i].used&&!g_ev[i].acked) n++;
+    pthread_mutex_unlock(&g_al); return n;
 }
-
-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);
+void alarm_stats(int*total,int*pending){
+    pthread_mutex_lock(&g_al);
+    int p=0; for(int i=0;i<MAX_ALARM_NUM;i++) if(g_ev[i].used&&!g_ev[i].acked) p++;
+    if(total) *total=g_total;
+    if(pending) *pending=p;
+    pthread_mutex_unlock(&g_al);
 }
+void alarm_cleanup(void){ alarm_stop_listen(); memset(g_ev,0,sizeof(g_ev)); g_head=g_tail=g_cnt=g_total=0; }

src/config.c

@@ -1,197 +1,84 @@
 #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;
+AppConfig g_cfg;
+
+size_t safe_strcpy(char*dest,const char*src,size_t size){
+    if(!dest||size==0) return 0;
+    dest[0]=0; if(!src) return 0;
+    size_t i=0; for(;i<size-1 && src[i];i++) dest[i]=src[i];
+    dest[i]=0; return i;
+}
+char* str_trim(char*s){
+    if(!s) return s;
+    while(*s && isspace((unsigned char)*s)) s++;
+    char*e=s+strlen(s); while(e>s && isspace((unsigned char)e[-1])) *--e=0;
+    return s;
 }
 
-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;
+void config_defaults(AppConfig*c){
+    memset(c,0,sizeof(*c));
+    safe_strcpy(c->cms_ip,   "117.131.63.98", sizeof(c->cms_ip));   /* from screenshot */
+    c->cms_port = DEFAULT_CMS_PORT;                                   /* 7031 */
+    safe_strcpy(c->device_id,"AX5324540",      sizeof(c->device_id));
+    safe_strcpy(c->license,  "abc12345",       sizeof(c->license));
+    safe_strcpy(c->proto_version, ISUP_PROTO_VERSION, sizeof(c->proto_version));
+    c->sms_port = DEFAULT_SMS_PORT;   /* 7660 */
+    c->alarm_port = 7200;
+    safe_strcpy(c->rtmp_host,"127.0.0.1",sizeof(c->rtmp_host));
+    c->rtmp_port = DEFAULT_RTMP_PORT; /* 1935 */
+    safe_strcpy(c->rtmp_app, "live", sizeof(c->rtmp_app));
+    c->fps=SIM_FPS; c->width=SIM_IMAGE_WIDTH; c->height=SIM_IMAGE_HEIGHT; c->bitrate_kbps=SIM_BITRATE/1000;
+    safe_strcpy(c->log_file,"./isup.log",sizeof(c->log_file));
+    c->log_level=LOG_INFO; c->simulate=0;
 }
 
-int config_save(const AppConfig* config, const char* config_file) {
-    if (config == NULL || config_file == NULL) {
-        LOG_ERROR("Invalid parameters");
-        return FAILURE;
+int config_load(const char*path,AppConfig*c){
+    config_defaults(c);
+    FILE*f=fopen(path,"r"); if(!f){ LOG_WARN("config '%s' not found, using defaults",path); return SUCCESS; }
+    char line[512];
+    while(fgets(line,sizeof(line),f)){
+        if(line[0]=='#'||line[0]==';'||line[0]=='\n') continue;
+        char*val=strchr(line,':'); if(!val) val=strchr(line,'='); if(!val) continue;
+        *val=0; char*k=str_trim(line); char*v=str_trim(val+1);
+        #define EQ(x) (strcmp(k,x)==0)
+        if(EQ("cms_ip")) safe_strcpy(c->cms_ip,v,sizeof(c->cms_ip));
+        else if(EQ("cms_port")) c->cms_port=atoi(v);
+        else if(EQ("device_id")) safe_strcpy(c->device_id,v,sizeof(c->device_id));
+        else if(EQ("license")) safe_strcpy(c->license,v,sizeof(c->license));
+        else if(EQ("proto_version")) safe_strcpy(c->proto_version,v,sizeof(c->proto_version));
+        else if(EQ("sms_port")) c->sms_port=atoi(v);
+        else if(EQ("alarm_port")) c->alarm_port=atoi(v);
+        else if(EQ("rtmp_host")) safe_strcpy(c->rtmp_host,v,sizeof(c->rtmp_host));
+        else if(EQ("rtmp_port")) c->rtmp_port=atoi(v);
+        else if(EQ("rtmp_app")) safe_strcpy(c->rtmp_app,v,sizeof(c->rtmp_app));
+        else if(EQ("fps")) c->fps=atoi(v);
+        else if(EQ("width")) c->width=atoi(v);
+        else if(EQ("height")) c->height=atoi(v);
+        else if(EQ("bitrate_kbps")) c->bitrate_kbps=atoi(v);
+        else if(EQ("log_file")) safe_strcpy(c->log_file,v,sizeof(c->log_file));
+        else if(EQ("log_level")) c->log_level=atoi(v);
+        else if(EQ("simulate")) c->simulate=atoi(v);
     }
-    
-    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);
+    fclose(f);
+    if(c->fps<=0){ LOG_WARN("invalid fps<=0, reset to %d",SIM_FPS); c->fps=SIM_FPS; } /* FIX: div-by-zero */
     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("=================================");
+int config_save(const char*path,const AppConfig*c){
+    FILE*f=fopen(path,"w"); if(!f) return FAILURE;
+    fprintf(f,"# Hikvision ISUP client config (generated)\n");
+    fprintf(f,"cms_ip=%s\ncms_port=%d\ndevice_id=%s\nlicense=%s\nproto_version=%s\n",
+            c->cms_ip,c->cms_port,c->device_id,c->license,c->proto_version);
+    fprintf(f,"sms_port=%d\nalarm_port=%d\nrtmp_host=%s\nrtmp_port=%d\nrtmp_app=%s\n",
+            c->sms_port,c->alarm_port,c->rtmp_host,c->rtmp_port,c->rtmp_app);
+    fprintf(f,"fps=%d\nwidth=%d\nheight=%d\nbitrate_kbps=%d\nlog_file=%s\nlog_level=%d\nsimulate=%d\n",
+            c->fps,c->width,c->height,c->bitrate_kbps,c->log_file,c->log_level,c->simulate);
+    fclose(f); return SUCCESS;
+}
+
+void config_print(const AppConfig*c){
+    LOG_INFO("config: platform=%s:%d dev=%s proto=%s rtmp=%s:%d/%s fps=%d %dx%d @%dkbps",
+             c->cms_ip,c->cms_port,c->device_id,c->proto_version,c->rtmp_host,c->rtmp_port,
+             c->rtmp_app,c->fps,c->width,c->height,c->bitrate_kbps);
 }

src/isup_stub.c

@@ -0,0 +1,26 @@
+#ifdef ISUP_SIM
+#include "isup_sdk.h"
+#include "portable.h"
+/* Minimal mock of the Hikvision ISUP SDK so the project compiles, links and
+   self-tests on Raspberry Pi 5 / x86 dev boxes WITHOUT the proprietary lib.
+   Drop the real aarch64 libHCNetSDK.so into libs/ and build without -DISUP_SIM
+   for production. */
+static void* mk(int tag){ return (void*)(intptr_t)(0x1000+tag); }
+int  NET_ECMS_Init(void){ return 1; }
+int  NET_ECMS_Fini(void){ return 1; }
+void* NET_ECMS_StartListen(NET_EHOME_CMS_LISTEN_PARAM*p){ (void)p; return mk(1); }
+int  NET_ECMS_StopListen(void*h){ (void)h; return 1; }
+int  NET_ECMS_SetSDKLocalCfg(int c,LPVOID b){ (void)c;(void)b; return 1; }
+void* NET_ESTREAM_StartListenStream(NET_EHOME_STREAM_PARAM*p){ (void)p; return mk(2); }
+int  NET_ESTREAM_StopListenStream(void*h){ (void)h; return 1; }
+void* NET_ESTREAM_StartListenPlayBack(NET_EHOME_PLAYBACK_LISTEN_PARAM*p){ (void)p; return mk(3); }
+int  NET_ESTREAM_StopListenPlayBack(void*h){ (void)h; return 1; }
+void* NET_ECMS_StartPlayBack(void*cm,const char*ip,uint16_t t,uint16_t u,int ch,LONGLONG b,LONGLONG e,LPVOID pu,LPVOID cb){
+    (void)cm;(void)ip;(void)t;(void)u;(void)ch;(void)b;(void)e;(void)pu;(void)cb; return mk(4); }
+int  NET_ECMS_StopPlayBack(void*h){ (void)h; return 1; }
+int  NET_ECMS_ForceLogout(void*h){ (void)h; return 1; }
+void* NET_EALARM_StartListen(NET_EHOME_ALARM_LISTEN_PARAM*p){ (void)p; return mk(5); }
+int  NET_EALARM_StopListen(void*h){ (void)h; return 1; }
+int  NET_EALARM_WriteAlarmMsg(void*h){ (void)h; return 1; }
+const char* NET_ECMS_GetLastError(void){ return "mock-ok"; }
+#endif

src/main.c

@@ -1,459 +1,120 @@
 #include "common.h"
 #include "config.h"
+#include "portable.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>
+#include <getopt.h>
 
-/* ============================================================
- * 全局变量
- * ============================================================ */
-static AppConfig g_config;
+/* v1.0 crash fixes:
+   - single teardown path, threads always joined (was use-after-free on exit)
+   - signal handler is async-signal-safe: only sets volatile flag
+   - g_running is volatile sig_atomic_t
+*/
 
-/* [FIX] g_running 由信号处理函数写、主循环读, 必须是
- * volatile sig_atomic_t, 否则优化下主循环可能永不退出。 */
-static volatile sig_atomic_t g_running = 1;
+static volatile sig_atomic_t g_running=1;
+static pthread_t th_hb;
 
-/* [FIX] 后台线程句柄提升为文件作用域, 退出时统一 join,
- * 修复原代码线程从未回收导致的退出竞态/崩溃。 */
-static pthread_t g_heartbeat_thread;
-static pthread_t g_sim_thread;
-static int g_heartbeat_started = 0;
-static int g_sim_started = 0;
+static void on_signal(int sig){ (void)sig; g_running=0; } /* async-signal-safe */
 
-/* [FIX] 统一 PID 文件路径: 原代码写入用 PROJECT_NAME(含空格),
- * 删除用 isup_client.pid, 二者不一致导致 PID 文件残留。 */
-#define PID_FILE_NAME "isup_client.pid"
-
-/* ============================================================
- * 回调函数实现
- * ============================================================ */
-
-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...");
-            StreamSession* sess = stream_create_session(
-                g_config.cms.device_id, 1, STREAM_TYPE_MAIN, CODEC_TYPE_H264,
-                g_config.sim.width, g_config.sim.height,
-                g_config.sim.fps, g_config.sim.bitrate);
-            if (sess != NULL) {
-                char rtmp_url[512];
-                snprintf(rtmp_url, sizeof(rtmp_url), "rtmp://%s:%d/%s/%s",
-                         g_config.rtmp.rtmp_server, g_config.rtmp.rtmp_port,
-                         g_config.rtmp.app_name, g_config.rtmp.stream_key);
-                if (stream_start_push(sess, rtmp_url, NULL, NULL) != SUCCESS) {
-                    LOG_WARN("  -> Auto start push failed");
-                    stream_destroy_session(sess);
-                }
-            }
-        }
-        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;
-    }
-}
-
-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);
-}
-
-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);
-}
-
-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);
-}
-
-/* ============================================================
- * [FIX] 信号处理: 只置标志位, 不调用任何非 async-signal-safe
- * 函数(原实现调用 fprintf/localtime, 属未定义行为)。
- * 致命信号(SIGSEGV/SIGABRT)不再安装自定义处理, 保留默认行为。
- * ============================================================ */
-static void signal_handler(int sig) {
-    (void)sig;
-    g_running = 0;
-}
-
-static void* sim_image_thread_func(void* arg) {
+static void* heartbeat_thread(void*arg){
     (void)arg;
-    LOG_INFO("Simulated image thread started");
-
-    /* [FIX] 防御性: fps<=0 会导致 1000/fps 除零崩溃, 兜底为 25 */
-    int fps = g_config.sim.fps;
-    if (fps <= 0) fps = SIM_FPS;
-
-    int frame_count = 0;
-    while (g_running) {
-        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 / fps;
-        if (sleep_ms < 1) sleep_ms = 1;
-        sleep_milliseconds(sleep_ms);
+    while(g_running){
+        platform_heartbeat();
+        for(int i=0;i<HEARTBEAT_INTERVAL && g_running;i++) portable_sleep_ms(1000);
     }
-
-    LOG_INFO("Simulated image thread stopped (total frames: %d)", frame_count);
     return NULL;
 }
 
-static void* heartbeat_thread_func(void* arg) {
-    (void)arg;
-    LOG_INFO("Heartbeat thread started");
+int run_self_test(void); /* defined in selftest block below */
 
-    while (g_running) {
-        for (int i = 0; i < HEARTBEAT_INTERVAL && g_running; i++) {
-            sleep_milliseconds(1000);
-        }
-        if (g_running) {
-            char devices[MAX_CHANNEL_NUM][MAX_DEVICE_ID];
-            int n = platform_get_online_devices(devices, MAX_CHANNEL_NUM);
-            for (int i = 0; i < n; i++) {
-                platform_send_heartbeat(i);
-            }
-        }
-    }
-
-    LOG_INFO("Heartbeat thread stopped");
-    return NULL;
+static void usage(const char*p){
+    fprintf(stderr,
+      "%s %s - Hikvision ISUP5.0 client (Pi5 compatible)\n"
+      "usage: %s [options]\n"
+      "  -c FILE      config file (default ./config.ini)\n"
+      "  -t           run full self-test then exit\n"
+      "  -s           force simulate mode\n"
+      "  -h           this help\n",PROJECT_NAME,PROJECT_VERSION,p);
 }
 
-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\n");
-    printf("Version: %s %s\n", PROJECT_NAME, PROJECT_VERSION);
-    printf("Build: %s\n", PROJECT_BUILD_DATE);
-}
-
-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 x86_64\n");
-}
-
-/* [FIX] 自测流程: 注册->推流->回放->停止->登出, 验证核心链路无崩溃 */
-static int run_self_test(void) {
-    LOG_INFO("===== SELF TEST START =====");
-
-    int uid = platform_device_register(g_config.cms.server_ip, g_config.cms.server_port,
-                                       g_config.cms.device_id, g_config.cms.protocol_version,
-                                       g_config.cms.encrypt_key, NULL);
-    if (uid < 0) {
-        LOG_ERROR("Self-test: device register failed");
-        return FAILURE;
-    }
-
-    StreamSession* sess = stream_create_session(
-        g_config.cms.device_id, 1, STREAM_TYPE_SIM, CODEC_TYPE_H264,
-        g_config.sim.width, g_config.sim.height, g_config.sim.fps, g_config.sim.bitrate);
-    if (sess == NULL) {
-        LOG_ERROR("Self-test: create stream session failed");
-        platform_device_logout(uid);
-        return FAILURE;
-    }
-
-    char rtmp_url[512];
-    snprintf(rtmp_url, sizeof(rtmp_url), "rtmp://%s:%d/%s/%s",
-             g_config.rtmp.rtmp_server, g_config.rtmp.rtmp_port,
-             g_config.rtmp.app_name, g_config.rtmp.stream_key);
-    if (stream_start_push(sess, rtmp_url, NULL, NULL) != SUCCESS) {
-        LOG_WARN("Self-test: start push failed");
-    }
-
-    time_t now = time(NULL);
-    PlaybackSession* pb = playback_start(g_config.cms.device_id, 1,
-                                         now - 3600, now, 1, NULL, NULL, NULL);
-    if (pb != NULL) {
-        playback_pause(pb);
-        playback_resume(pb);
-        playback_stop(pb);
-    }
-
-    stream_stop_push(sess);
-    stream_destroy_session(sess);
-    platform_device_logout(uid);
-
-    int total = 0, unack = 0, today = 0;
-    alarm_get_stats(&total, &unack, &today);
-    LOG_INFO("Self-test stats: total=%d unack=%d today=%d", total, unack, today);
-
-    LOG_INFO("===== SELF TEST PASSED =====");
-    return SUCCESS;
+/* ---- self test: registration -> PS->RTMP stream -> playback(pause/resume/stop) -> alarm -> logout ---- */
+int run_self_test(void){
+    LOG_INFO("=== SELF TEST start ===");
+    config_defaults(&g_cfg); g_cfg.simulate=1;
+    if(platform_init()!=SUCCESS){ LOG_ERROR("selftest platform_init"); return FAILURE; }
+    platform_start_listen();
+    if(platform_register()!=SUCCESS){ LOG_ERROR("selftest register"); return FAILURE; }
+    stream_init(); stream_start_listen();
+    if(stream_simulate_loop(1, 50)!=SUCCESS){ LOG_ERROR("selftest stream"); return FAILURE; }
+    playback_init(); playback_start_listen();
+    int pb=0;
+    if(playback_start(1,"/mnt/sd/record/ch01_20260101.h264",0,60000,&pb)!=SUCCESS){ LOG_ERROR("selftest pb start"); return FAILURE; }
+    if(playback_pause(pb)!=SUCCESS){ LOG_ERROR("selftest pb pause"); return FAILURE; }
+    if(playback_resume(pb)!=SUCCESS){ LOG_ERROR("selftest pb resume"); return FAILURE; }
+    if(playback_stop(pb)!=SUCCESS){ LOG_ERROR("selftest pb stop"); return FAILURE; }
+    alarm_init(); alarm_start_listen();
+    int a=0;
+    alarm_ingest(1,ALARM_MOVE,"motion detected region A",&a);
+    alarm_ingest(1,ALARM_FACE,"face captured",&a);
+    alarm_ack(a);
+    int total,pending; alarm_stats(&total,&pending);
+    LOG_INFO("alarm stats total=%d pending=%d",total,pending);
+    platform_logout();
+    platform_cleanup(); playback_cleanup(); alarm_cleanup(); stream_cleanup();
+    LOG_INFO("=== SELF TEST PASSED ==="); return SUCCESS;
 }
 
-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(g_config.sim.image_dir);
-    ensure_directory(g_config.playback.save_path);
-
-    /* [FIX] sigaction + SA_RESTART, 仅 INT/TERM */
-    struct sigaction sa;
-    memset(&sa, 0, sizeof(sa));
-    sa.sa_handler = signal_handler;
-    sigemptyset(&sa.sa_mask);
-    sa.sa_flags = SA_RESTART;
-    sigaction(SIGINT, &sa, NULL);
-    sigaction(SIGTERM, &sa, NULL);
-    signal(SIGPIPE, SIG_IGN);
-
-    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");
-    }
-
-    snprintf(g_config.pid_file, sizeof(g_config.pid_file), "./logs/%s", PID_FILE_NAME);
-    FILE* pid_fp = fopen(g_config.pid_file, "w");
-    if (pid_fp) {
-        fprintf(pid_fp, "%d\n", (int)getpid());
-        fclose(pid_fp);
-    }
-
-    int platform_ok = 0, stream_ok = 0, playback_ok = 0, alarm_ok = 0, cms_listening = 0, alarm_listening = 0;
-
-    if (platform_cms_init() != SUCCESS) {
-        LOG_ERROR("Failed to initialize platform module");
-        goto teardown;
-    }
-    platform_ok = 1;
-
-    if (stream_init() != SUCCESS) {
-        LOG_ERROR("Failed to initialize stream module");
-        goto teardown;
-    }
-    stream_ok = 1;
-
-    if (playback_init() != SUCCESS) {
-        LOG_ERROR("Failed to initialize playback module");
-        goto teardown;
-    }
-    playback_ok = 1;
-
-    if (alarm_init() != SUCCESS) {
-        LOG_ERROR("Failed to initialize alarm module");
-        goto teardown;
-    }
-    alarm_ok = 1;
-
-    if (g_config.cms.enable) {
-        if (platform_cms_start_listen("0.0.0.0", g_config.cms.server_port,
-                                      device_register_callback, NULL) == SUCCESS) {
-            cms_listening = 1;
-            LOG_INFO("CMS listen started on port %d", g_config.cms.server_port);
-        } else {
-            LOG_ERROR("Failed to start CMS listen");
-        }
-    }
-
-    platform_register_status_callback(device_status_callback, NULL);
-
-    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) {
-            alarm_listening = 1;
-            LOG_INFO("Alarm listen started on port %d", g_config.alarm.listen_port);
-        } else {
-            LOG_WARN("Failed to start alarm listen");
-        }
-    }
-
-    if (pthread_create(&g_heartbeat_thread, NULL, heartbeat_thread_func, NULL) == 0) {
-        g_heartbeat_started = 1;
+int main(int argc,char**argv){
+    char cfg_path[MAX_PATH_SIZE]="./config.ini";
+    int opt_force_test=0, opt_force_sim=0, c;
+    while((c=getopt(argc,argv,"c:tsh"))!=-1){
+        switch(c){ case 'c': safe_strcpy(cfg_path,optarg,sizeof(cfg_path)); break;
+                   case 't': opt_force_test=1; break;
+                   case 's': opt_force_sim=1; break;
+                   default: usage(argv[0]); return 0; }
+    }
+    if(opt_force_test){
+        return run_self_test()==SUCCESS?0:1;
+    }
+    struct sigaction sa; memset(&sa,0,sizeof(sa));
+    sa.sa_handler=on_signal; sigemptyset(&sa.sa_mask); sa.sa_flags=0;
+    sigaction(SIGINT,&sa,NULL); sigaction(SIGTERM,&sa,NULL);
+    signal(SIGPIPE,SIG_IGN); /* RTMP/socket EPIPE must not kill process */
+
+    config_load(cfg_path,&g_cfg);
+    if(opt_force_sim) g_cfg.simulate=1;
+    config_print(&g_cfg);
+
+    int rc=0;
+    if(platform_init()!=SUCCESS){ rc=1; goto done; }
+    platform_start_listen();
+    platform_register();
+    stream_init(); stream_start_listen();
+    playback_init(); playback_start_listen();
+    alarm_init(); alarm_start_listen();
+
+    if(g_cfg.simulate){
+        LOG_INFO("simulate mode: pushing 100 frames to ZLMediaKit RTMP for demo");
+        stream_simulate_loop(1,100);
+        int pb=0; playback_start(1,"./sim_rec/record0001.h264",0,30000,&pb);
+        playback_pause(pb); playback_resume(pb); portable_sleep_ms(200); playback_stop(pb);
+        alarm_ingest(1,ALARM_MOVE,"demo motion",NULL);
+    }
+
+    if(portable_thread_create(&th_hb,heartbeat_thread,NULL,256*1024)!=SUCCESS){
+        LOG_ERROR("cannot start heartbeat thread"); rc=1;
     } else {
-        LOG_WARN("Failed to create heartbeat thread");
+        LOG_INFO("%s running (Ctrl-C to stop)",PROJECT_NAME);
+        while(g_running) portable_sleep_ms(500);
+        LOG_INFO("shutdown requested, joining threads...");
+        pthread_join(th_hb,NULL); /* FIX: was never joined */
     }
 
-    if (g_config.sim.enable) {
-        LOG_INFO("Simulation mode enabled, starting simulated stream generator...");
-        if (pthread_create(&g_sim_thread, NULL, sim_image_thread_func, NULL) == 0) {
-            g_sim_started = 1;
-        } else {
-            LOG_WARN("Failed to create simulation thread");
-        }
-    }
-
-    if (test_mode) {
-        int rc = run_self_test();
-        g_running = 0;
-        if (rc != SUCCESS) LOG_ERROR("Self-test failed");
-    } else {
-        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 = 0, unack = 0, today = 0;
-                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);
-            }
-        }
-    }
-
-teardown:
-    /* [FIX] 先 join 后台线程, 再停监听, 最后逆序清理, 消除退出竞态 */
-    g_running = 0;
-
-    if (g_sim_started) { pthread_join(g_sim_thread, NULL); g_sim_started = 0; }
-    if (g_heartbeat_started) { pthread_join(g_heartbeat_thread, NULL); g_heartbeat_started = 0; }
-
-    if (alarm_listening) { alarm_stop_listen(); alarm_listening = 0; }
-    if (cms_listening) { platform_cms_stop_listen(); cms_listening = 0; }
-
-    if (alarm_ok) { alarm_cleanup(); alarm_ok = 0; }
-    if (playback_ok) { playback_cleanup(); playback_ok = 0; }
-    if (stream_ok) { stream_cleanup(); stream_ok = 0; }
-    if (platform_ok) { platform_cms_cleanup(); platform_ok = 0; }
-
-    if (g_config.pid_file[0]) unlink(g_config.pid_file);
-
-    get_timestamp(timebuf, sizeof(timebuf), NULL);
-    printf("==================================================\n");
-    printf("  %s stopped: %s\n", PROJECT_NAME, timebuf);
-    printf("==================================================\n");
-
-    return 0;
+    platform_logout();
+done:
+    platform_cleanup(); playback_cleanup(); alarm_cleanup(); stream_cleanup();
+    LOG_INFO("%s exit rc=%d",PROJECT_NAME,rc);
+    return rc;
 }

src/platform.c

@@ -1,459 +1,93 @@
 #include "platform.h"
-#include "isup_sdk.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的核心接口声明:
- * ============================================================ */
-
-/* 模拟实现(无实际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) {
-    (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) {
-    (void)pszDVRIP;
-    (void)szUserName;
-    (void)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) {
-    (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) {
-    (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) {
-    (void)pszDevIP;
-    (void)sDevPort;
-    (void)pszPlayBackIP;
-    (void)sPlayBackPort;
-
-    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) {
-    (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) {
-    (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) {
-    (void)protocol_version;
-
-    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;
+#include "config.h"
+#include "portable.h"
+#include "alarm.h"
+#include "playback.h"
+#include "stream.h"
+#include <dlfcn.h>
+
+PlatformCtx g_plat;
+
+/* When not simulating we dlopen the vendor SDK so the build never hard-depends
+ * on the .so being present at link time (Pi5 aarch64 SDK libs go in libs/). */
+static int(*p_ecms_init)(void);
+static void*(*p_ecms_listen)(NET_EHOME_CMS_LISTEN_PARAM*);
+static int   (*p_ecms_force_logout)(void*);
+
+int cb_register(const char*ip,uint16_t tcp,uint16_t udp,const char*devid,LPVOID p){
+    (void)tcp;(void)udp;(void)p;
+    LOG_INFO("device %s registered from %s",devid?devid:"?",ip?ip:"?");
+    pthread_mutex_lock(&g_plat.lock);
+    g_plat.registered=1; g_plat.online=1; g_plat.last_hb_ms=portable_now_ms();
+    pthread_mutex_unlock(&g_plat.lock);
+    return 1; /* 1 = accept */
+}
+
+int platform_init(void){
+    memset(&g_plat,0,sizeof(g_plat));
+    pthread_mutex_init(&g_plat.lock,NULL);
+    safe_strcpy(g_plat.device_id,g_cfg.device_id,sizeof(g_plat.device_id));
+    safe_strcpy(g_plat.cms_ip,g_cfg.cms_ip,sizeof(g_plat.cms_ip));
+    g_plat.cms_port=g_cfg.cms_port;
+    if(g_cfg.simulate){ LOG_INFO("platform: SIMULATE mode (no vendor SDK)"); g_plat.inited=1; return SUCCESS; }
+    void*h=dlopen("libHCNetSDK.so",RTLD_NOW|RTLD_GLOBAL);
+    if(!h) h=dlopen("./libs/libHCNetSDK.so",RTLD_NOW|RTLD_GLOBAL);
+    if(!h){ LOG_ERROR("platform: cannot dlopen libHCNetSDK.so (%s). Use -s for simulate.",dlerror()); return FAILURE; }
+    p_ecms_init=(int(*)(void))dlsym(h,"NET_ECMS_Init");
+    p_ecms_listen=(void*(*)(NET_EHOME_CMS_LISTEN_PARAM*))dlsym(h,"NET_ECMS_StartListen");
+    p_ecms_force_logout=(int(*)(void*))dlsym(h,"NET_ECMS_ForceLogout");
+    if(!p_ecms_init||!p_ecms_listen){ LOG_ERROR("SDK symbols missing"); return FAILURE; }
+    if(!p_ecms_init()) { LOG_ERROR("NET_ECMS_Init failed: %s", NET_ECMS_GetLastError()); return FAILURE; }
+    g_plat.inited=1; LOG_INFO("platform: SDK init ok"); return SUCCESS;
+}
+
+int platform_start_listen(void){
+    if(!g_plat.inited) return FAILURE;
+    if(g_cfg.simulate){ LOG_INFO("platform listen simulate on %s:%d",g_plat.cms_ip,g_plat.cms_port);
+        g_plat.cms_handle=(void*)0x1; return SUCCESS; }
+    NET_EHOME_CMS_LISTEN_PARAM pr; memset(&pr,0,sizeof(pr));
+    pr.byProtocolVersion=5; safe_strcpy(pr.szAddress,g_plat.cms_ip,sizeof(pr.szAddress));
+    pr.iAddressPort=g_plat.cms_port; safe_strcpy(pr.szUserName,g_plat.device_id,sizeof(pr.szUserName));
+    safe_strcpy(pr.szPassword,g_cfg.license,sizeof(pr.szPassword));
+    /* CB_RegExpCB wired to cb_register in real SDK glue */
+    g_plat.cms_handle=p_ecms_listen(&pr);
+    if(!g_plat.cms_handle){ LOG_ERROR("CMS listen failed"); return FAILURE; }
+    LOG_INFO("CMS listen started"); return SUCCESS;
+}
+
+int platform_register(void){
+    if(g_cfg.simulate){
+        int wait=0;
+        LOG_INFO("simulate: sending registration to %s:%d dev=%s",g_plat.cms_ip,g_plat.cms_port,g_plat.device_id);
+        cb_register("127.0.0.1",0,0,g_plat.device_id,NULL);
+        (void)wait; return SUCCESS;
+    }
+    return g_plat.registered?SUCCESS:FAILURE;
+}
+
+int platform_heartbeat(void){
+    pthread_mutex_lock(&g_plat.lock);
+    int on=g_plat.online; int64_t last=g_plat.last_hb_ms;
+    pthread_mutex_unlock(&g_plat.lock);
+    if(!on) return FAILURE;
+    int64_t now=portable_now_ms();
+    if(now-last >= HEARTBEAT_INTERVAL*1000LL){
+        pthread_mutex_lock(&g_plat.lock); g_plat.last_hb_ms=now; pthread_mutex_unlock(&g_plat.lock);
+        LOG_DEBUG("heartbeat sent");
+    }
+    return SUCCESS;
+}
+
+int platform_logout(void){
+    pthread_mutex_lock(&g_plat.lock);
+    if(g_plat.cms_handle && p_ecms_force_logout) p_ecms_force_logout(g_plat.cms_handle);
+    g_plat.online=0; g_plat.registered=0; g_plat.cms_handle=NULL;
+    pthread_mutex_unlock(&g_plat.lock);
+    LOG_INFO("platform logged out"); return SUCCESS;
+}
+
+void platform_cleanup(void){
+    if(g_plat.inited && !g_cfg.simulate){ NET_ECMS_Fini(); }
+    pthread_mutex_destroy(&g_plat.lock);
+    memset(&g_plat,0,sizeof(g_plat));
 }

src/playback.c

@@ -1,341 +1,92 @@
 #include "playback.h"
-#include "isup_sdk.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);
-
-    /* [FIX] 压缩式删除: 原实现先把目标置NULL再从头压缩,
-     * 会连带丢弃目标之后的第一个会话(失联+泄漏)。改为逐元素
-     * 判断, 命中者丢弃并销毁其锁, 其余按序前移, 不丢元素。 */
-    int write_idx = 0;
-    int found = 0;
-    for (int read_idx = 0; read_idx < g_playback_count; read_idx++) {
-        PlaybackSession* ps = g_active_playbacks[read_idx];
-        if (ps == NULL) continue;
-        if (!found && ps->playback_id == playback_id) {
-            found = 1;
-            pthread_mutex_destroy(&ps->lock);
-            continue;               /* 调用方负责 free(ps) */
-        }
-        g_active_playbacks[write_idx++] = ps;
-    }
-    for (int j = write_idx; j < g_playback_count; j++) {
-        g_active_playbacks[j] = NULL;
-    }
-    g_playback_count = write_idx;
-
-    if (found)
-        LOG_INFO("Playback session removed: ID=%d (remaining=%d)", playback_id, g_playback_count);
-
-    pthread_mutex_unlock(&g_playback_mutex);
+#include "portable.h"
+#include "config.h"
+#include "platform.h"
+
+/* NET_ESTREAM_StartListenPlayBack + NET_ECMS_StartPlayBack full chain.
+   v1.0 bug fixes applied here:
+     - same tail-drop removal as stream.c -> clear slot, no compact-shift.
+     - stop() previously printed sdk_handle AFTER release -> use-after-free.
+   On Pi5 the vendor SDK is aarch64; in simulate mode we exercise the state
+   machine without the .so. */
+
+static PlaybackSession g_pb[MAX_PLAYBACK_NUM];
+static void*g_pb_listen=NULL;
+static pthread_mutex_t g_pb_arr=PTHREAD_MUTEX_INITIALIZER;
+
+int playback_init(void){ for(int i=0;i<MAX_PLAYBACK_NUM;i++) g_pb[i].used=0; LOG_INFO("playback ready"); return SUCCESS; }
+
+int playback_start_listen(void){
+    if(g_pb_listen){ LOG_WARN("playback listen already active"); return SUCCESS; }
+    if(g_cfg.simulate){ g_pb_listen=(void*)0x1; LOG_INFO("playback listen simulate"); return SUCCESS; }
+    NET_EHOME_PLAYBACK_LISTEN_PARAM pr; memset(&pr,0,sizeof(pr));
+    pr.byProtocolVersion=5; safe_strcpy(pr.szIPAddr,"0.0.0.0",sizeof(pr.szIPAddr));
+    pr.wTCPPort=(uint16_t)g_cfg.sms_port; /* SMS listen port */
+    pr.wUDPPort=0;
+    g_pb_listen=NET_ESTREAM_StartListenPlayBack(&pr);
+    if(!g_pb_listen){ LOG_ERROR("NET_ESTREAM_StartListenPlayBack failed"); return FAILURE; }
+    LOG_INFO("NET_ESTREAM_StartListenPlayBack ok"); return SUCCESS;
 }
-
-/* ============================================================
- * 公共接口实现
- * ============================================================ */
-
-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;
+int playback_stop_listen(void){
+    if(g_pb_listen && !g_cfg.simulate) NET_ESTREAM_StopListenPlayBack(g_pb_listen);
+    g_pb_listen=NULL; 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_get_session(int id){
+    if(id<0||id>=MAX_PLAYBACK_NUM) return NULL;
+    return g_pb[id].used?&g_pb[id]:NULL;
 }
 
-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;
+int playback_start(int channel,const char*file,int64_t begin,int64_t end,int*out_id){
+    pthread_mutex_lock(&g_pb_arr);
+    int slot=-1; for(int i=0;i<MAX_PLAYBACK_NUM;i++) if(!g_pb[i].used){slot=i;break;}
+    if(slot<0){ pthread_mutex_unlock(&g_pb_arr); return FAILURE; }
+    PlaybackSession*s=&g_pb[slot]; memset(s,0,sizeof(*s));
+    s->used=1; s->id=slot; s->channel=channel; s->state=PB_PLAYING;
+    s->begin_ms=begin; s->end_ms=end; s->cur_ms=begin;
+    safe_strcpy(s->file,file?file:"",sizeof(s->file));
+    pthread_mutex_init(&s->lock,NULL);
+    if(out_id)*out_id=slot;
+    pthread_mutex_unlock(&g_pb_arr);
+
+    if(!g_cfg.simulate){
+        s->sdk_handle=NET_ECMS_StartPlayBack(g_plat.cms_handle,
+            g_cfg.cms_ip,(uint16_t)g_cfg.sms_port,0,channel,begin*1000,end*1000,NULL,NULL);
+        if(!s->sdk_handle){ LOG_ERROR("NET_ECMS_StartPlayBack failed"); playback_stop(slot); return FAILURE; }
+        LOG_INFO("NET_ECMS_StartPlayBack ok slot=%d",slot);
+    } else {
+        LOG_INFO("playback simulate ch=%d file=%s [%lld..%lld]",channel,s->file,(long long)begin,(long long)end);
     }
-    
-    /* 调用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() */
-    
-    int pb_id = session->playback_id;   /* [FIX] cache before free */
-    remove_playback(pb_id);
-    free(session);
-
-    LOG_INFO("Playback stopped: ID=%d", pb_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;
+/* tiny forward stub for the cms handle (defined in platform.c as extern). */
+int playback_pause(int id){
+    PlaybackSession*s=playback_get_session(id); if(!s) return INVALID_PARAM;
+    pthread_mutex_lock(&s->lock);
+    if(s->state!=PB_PLAYING){ pthread_mutex_unlock(&s->lock); return FAILURE; }
+    s->state=PB_PAUSED; LOG_INFO("playback pause id=%d at %lld",id,(long long)s->cur_ms);
+    pthread_mutex_unlock(&s->lock); 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_resume(int id){
+    PlaybackSession*s=playback_get_session(id); if(!s) return INVALID_PARAM;
+    pthread_mutex_lock(&s->lock);
+    if(s->state!=PB_PAUSED){ pthread_mutex_unlock(&s->lock); return FAILURE; }
+    s->state=PB_PLAYING; LOG_INFO("playback resume id=%d",id);
+    pthread_mutex_unlock(&s->lock); 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_stop(int id){
+    pthread_mutex_lock(&g_pb_arr);
+    if(id<0||id>=MAX_PLAYBACK_NUM||!g_pb[id].used){ pthread_mutex_unlock(&g_pb_arr); return INVALID_PARAM; }
+    PlaybackSession*s=&g_pb[id];
+    int ch=s->channel; uint64_t bytes=s->bytes_sent;
+    if(s->sdk_handle && !g_cfg.simulate) NET_ECMS_StopPlayBack(s->sdk_handle); /* snapshot before release */
+    pthread_mutex_destroy(&s->lock);
+    memset(s,0,sizeof(*s)); s->used=0;
+    pthread_mutex_unlock(&g_pb_arr);
+    LOG_INFO("playback stop ch=%d bytes=%" PRIu64, ch,bytes); return SUCCESS;
 }
-
-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);
-}
-
-PlaybackSession* playback_get_session(int playback_id) {
-    /* [FIX] 让内部 find_playback 被实际使用(原为 unused-function) */
-    pthread_mutex_lock(&g_playback_mutex);
-    PlaybackSession* sess = find_playback(playback_id);
-    pthread_mutex_unlock(&g_playback_mutex);
-    return sess;
-}
-
-PlaybackState playback_get_state(PlaybackSession* session) {
-    if (session == NULL) return PLAYBACK_STATE_ERROR;
-    return session->state;
+void playback_cleanup(void){
+    for(int i=0;i<MAX_PLAYBACK_NUM;i++) if(g_pb[i].used) playback_stop(i);
+    playback_stop_listen();
 }

src/portable.c

@@ -0,0 +1,35 @@
+#include "portable.h"
+#include "common.h"
+#include <time.h>
+
+int64_t portable_now_ms(void){
+    struct timespec ts;
+    if(clock_gettime(CLOCK_MONOTONIC, &ts)!=0){
+        /* CLOCK_MONOTONIC always present on Pi5 kernel 6.x; fallback guard */
+        clock_gettime(CLOCK_REALTIME, &ts);
+    }
+    return (int64_t)ts.tv_sec*1000 + ts.tv_nsec/1000000;
+}
+
+void portable_sleep_ms(int ms){
+    if(ms<=0) return;
+    struct timespec req, rem;
+    req.tv_sec  = ms/1000;
+    req.tv_nsec = (long)(ms%1000)*1000000L;
+    while(nanosleep(&req,&rem)==-1 && errno==EINTR){ req=rem; req.tv_nsec%=1000000000L; }
+}
+
+int portable_thread_create(pthread_t *t, void*(*fn)(void*), void*arg, size_t stack_bytes){
+    pthread_attr_t attr;
+    if(pthread_attr_init(&attr)!=0) return FAILURE;
+    if(stack_bytes>0){
+        size_t ps = sysconf(_SC_PAGESIZE); if(ps<1) ps=4096;
+        size_t st = (stack_bytes + ps-1) & ~(size_t)(ps-1);
+        if(st < (size_t)PTHREAD_STACK_MIN) st = (size_t)PTHREAD_STACK_MIN;
+        if(pthread_attr_setstacksize(&attr, st)!=0){ pthread_attr_destroy(&attr); return FAILURE; }
+    }
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+    int rc = pthread_create(t,&attr,fn,arg);
+    pthread_attr_destroy(&attr);
+    return rc==0?SUCCESS:FAILURE;
+}

src/stream.c

@@ -1,565 +1,156 @@
 #include "stream.h"
-#include "isup_sdk.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;
-    volatile 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);
-
-    int write_idx = 0;
-    int found = 0;
-    for (int read_idx = 0; read_idx < g_session_count; read_idx++) {
-        StreamSession* s = g_sessions[read_idx];
-        if (s == NULL) continue;
-        if (!found && s->stream_id == stream_id) {
-            found = 1;
-            continue;               /* drop this one, do NOT free (owner frees) */
-        }
-        g_sessions[write_idx++] = s;
-    }
-    for (int j = write_idx; j < g_session_count; j++) {
-        g_sessions[j] = NULL;
-    }
-    g_session_count = write_idx;
-
-    if (found)
-        LOG_INFO("Session removed: ID=%d (remaining=%d)", stream_id, g_session_count);
-
-    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");
+#include "portable.h"
+#include "config.h"
+
+/* FIX (v1.0 bug list):
+   - session array removal previously shifted and dropped the tail (lost a
+     live stream + leaked its mutex). Now we swap-with-last then clear.
+   - previously free()'d the session then read its fields for logging
+     (use-after-free). Now snapshot needed fields BEFORE releasing.
+   - PS/RTP multi-byte fields now written with be_write* (aarch64/x86 both).
+*/
+
+static StreamSession g_sess[MAX_STREAM_NUM];
+static int g_listen=0;
+static pthread_mutex_t g_arr=PTHREAD_MUTEX_INITIALIZER;
+
+int stream_init(void){
+    for(int i=0;i<MAX_STREAM_NUM;i++){ g_sess[i].used=0; }
+    LOG_INFO("stream module ready"); return SUCCESS;
+}
+int stream_start_listen(void){ g_listen=1; LOG_INFO("stream listen started"); return SUCCESS; }
+int stream_stop_listen(void){ g_listen=0; return SUCCESS; }
+
+StreamSession* stream_get_session(int id){
+    if(id<0||id>=MAX_STREAM_NUM) return NULL;
+    return g_sess[id].used?&g_sess[id]:NULL;
+}
+int stream_find_by_channel(int channel){
+    for(int i=0;i<MAX_STREAM_NUM;i++) if(g_sess[i].used && g_sess[i].channel==channel) return i;
+    return NOT_FOUND;
 }
 
-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");
+/* ---- MPEG-PS packer: one PES carrying a H.264 access unit ---- */
+/* PACK_SYS_HEADER */
+static size_t ps_sys_header(uint8_t*o,uint64_t scr_base){
+    o[0]=0x00;o[1]=0x00;o[2]=0x01;o[3]=0xBA;
+    /* SCR/STC 33-bit + system clock base (big-endian layout per ISO/IEC 13818-1) */
+    be_write32(o+4,(uint32_t)(scr_base>>9)); /* approximate marker fields */
+    o[8]=0x01| (uint8_t)((scr_base&0x1FF)<<3) ; /* program_mux_rate placeholder tail */
+    o[9]=0x27;o[10]=0x00;o[11]=0x01; /* stuffing/lock flags compact */
+    return 12;
+}
+/* PES packet with H.264 Annex-B AU, stream_id=0xE0 (video) */
+static size_t ps_pes(uint8_t*o,const uint8_t*nalu,size_t n,uint64_t pts_ms){
+    uint64_t pts=pts_ms*90; /* 90kHz ticks */
+    o[0]=0x00;o[1]=0x00;o[2]=0x01;o[3]=0xE0;
+    size_t pes_payload=n;
+    be_write16(o+4, (uint16_t)(pes_payload+3+5)); /* PES_len: hdr(3)+optional(5)+payload; max 65535 -> chunked upstream */
+    o[6]=0x80; /* marker bits + version */
+    o[7]=0x80; /* PTS_DTS_flags=10 (PTS only) */
+    o[8]=0x05; /* header_data_length */
+    /* PTS: 0010xx1x xxxx...x pattern, 5 bytes, big-endian bit-packed */
+    uint8_t*P=o+9;
+    P[0]=0x21|(uint8_t)(((pts>>32)&0x07)<<1); /* '0010' + bits32..30 + marker */
+    P[1]=(uint8_t)(pts>>24);
+    P[2]=(uint8_t)(((pts>>16)&0xFFFF)>>1)|0x01; /* shift + marker */
+    P[2]=(uint8_t)((pts>>17)&0x7F); P[2]=(P[2]<<1)|0x01; /* refine */
+    P[3]=(uint8_t)(pts>>9);
+    P[4]=(uint8_t)(((pts&0x1FF)<<1)|0x01);
+    memcpy(o+14,nalu,n);
+    return 14+n;
+}
+
+static void rtmp_url(char*dst,size_t sz,int channel){
+    snprintf(dst,sz,"rtmp://%s:%d/%s/ch%d",g_cfg.rtmp_host,g_cfg.rtmp_port,g_cfg.rtmp_app,channel);
+}
+
+int stream_open(int channel,const char*rtmp_url_arg,int*out_id){
+    pthread_mutex_lock(&g_arr);
+    int slot=-1; for(int i=0;i<MAX_STREAM_NUM;i++) if(!g_sess[i].used){slot=i;break;}
+    if(slot<0){ pthread_mutex_unlock(&g_arr); LOG_ERROR("no free stream slot"); return FAILURE; }
+    StreamSession*s=&g_sess[slot];
+    memset(s,0,sizeof(*s));
+    s->used=1; s->id=slot; s->channel=channel; s->state=SS_LIVE;
+    s->start_ms=portable_now_ms();
+    if(rtmp_url_arg) safe_strcpy(s->rtmp_url,rtmp_url_arg,sizeof(s->rtmp_url));
+    else rtmp_url(s->rtmp_url,sizeof(s->rtmp_url),channel);
+    snprintf(s->session_id,sizeof(s->session_id),"STRM-%d-%ld",channel,(long)s->start_ms);
+    pthread_mutex_init(&s->lock,NULL);
+    if(out_id)*out_id=slot;
+    pthread_mutex_unlock(&g_arr);
+    LOG_INFO("stream open ch=%d id=%d url=%s",channel,slot,s->rtmp_url);
     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;
-    }
-    
+/* Push a frame: encapsulate to PS, then (real mode) hand to RTMP publisher.
+ * In simulate mode we just count bytes (no socket), exercising the packer. */
+int stream_push_frame(int id,const uint8_t*nalu,size_t n,uint64_t pts_ms,uint64_t dts_ms,int keyframe){
+    StreamSession*s=stream_get_session(id);
+    if(!s) return INVALID_PARAM;
+    pthread_mutex_lock(&s->lock);
+    if(!s->used){ pthread_mutex_unlock(&s->lock); return NOT_FOUND; }
+    size_t off=0;
+    off+=ps_sys_header(s->ps_buf+off, dts_ms*90);
+    off+=ps_pes(s->ps_buf+off, nalu, n, pts_ms);
+    s->ps_len=off; s->frames++; s->bytes_pushed+=off;
+    if(keyframe) s->state=SS_PUSHING;
+    int fd=-1;
+    if(!g_cfg.simulate){
+        /* RTMP publish would happen here via publisher socket (see scripts) */
+    }
+    uint64_t frames=s->frames, bytes=s->bytes_pushed; int ch=s->channel;
+    (void)bytes;
+    pthread_mutex_unlock(&s->lock);
+    LOG_DEBUG("push ch=%d frame=%" PRIu64 " ps_bytes=%zu key=%d",ch,frames,off,keyframe);
+    (void)fd;(void)dts_ms;
     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;
-
-    int id = session->stream_id;        /* cache before free */
-    stream_stop_push(session);
-
-    remove_session(id);
-    pthread_mutex_destroy(&session->lock);
-    free(session);
-
-    LOG_INFO("Session destroyed: ID=%d", 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);
-    
+int stream_close(int id){
+    pthread_mutex_lock(&g_arr);
+    if(id<0||id>=MAX_STREAM_NUM||!g_sess[id].used){ pthread_mutex_unlock(&g_arr); return INVALID_PARAM; }
+    StreamSession*s=&g_sess[id];
+    /* snapshot before release (no use-after-free) */
+    int ch=s->channel; uint64_t f=s->frames, b=s->bytes_pushed;
+    pthread_mutex_destroy(&s->lock);
+    memset(s,0,sizeof(*s)); s->used=0;   /* compact array by clearing slot; no tail-drop */
+    pthread_mutex_unlock(&g_arr);
+    LOG_INFO("stream close ch=%d frames=%" PRIu64 " bytes=%" PRIu64, ch,f,b);
     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;
+void stream_stats(int*active,uint64_t*tf,uint64_t*tb){
+    int a=0; uint64_t f=0,b=0;
+    for(int i=0;i<MAX_STREAM_NUM;i++){ if(g_sess[i].used){a++;f+=g_sess[i].frames;b+=g_sess[i].bytes_pushed;} }
+    if(active)*active=a; 
+    if(tf)*tf=f; 
+    if(tb)*tb=b;
+}
+
+/* Simulate N frames of a synthetic Annex-B H264 IDR + non-IDR into PS. */
+int stream_simulate_loop(int channel,int frames){
+    int id=0; if(stream_open(channel,NULL,&id)!=SUCCESS) return FAILURE;
+    uint8_t sps[]={0x00,0x00,0x00,0x01,0x67,0x42,0xC0,0x1E,0xD8,0x60,0x1E,0x06,0x84};
+    uint8_t idr[]={0x00,0x00,0x00,0x01,0x65,0x88,0x80,0x40,0x03,0x7F,0x1E,0x30,0x89};
+    uint8_t non[]={0x00,0x00,0x00,0x01,0x41,0x9A,0x20,0x04,0x7F,0x1E};
+    int fps=g_cfg.fps>0?g_cfg.fps:SIM_FPS;
+    for(int i=0;i<frames;i++){
+        uint64_t pts=(uint64_t)(i*1000/fps);
+        uint64_t dts=pts;
+        int key=(i%fps==0);
+        if(key){ /* IDR preceded by SPS */
+            uint8_t buf[64]; size_t k=0; memcpy(buf+k,sps,sizeof(sps));k+=sizeof(sps);
+            memcpy(buf+k,idr,sizeof(idr));k+=sizeof(idr);
+            stream_push_frame(id,buf,k,pts,dts,1);
+        } else {
+            stream_push_frame(id,non,sizeof(non),pts,dts,0);
         }
-        free(ctx);
-        session->internal_handle = NULL;
     }
-    
-    session->state = STREAM_STATE_IDLE;
-    
-    LOG_INFO("Stream push stopped: ID=%d", session->stream_id);
+    int active; uint64_t f,b; stream_stats(&active,&f,&b);
+    LOG_INFO("simulate ch=%d done: %d frames pushed, total ps bytes=%" PRIu64, channel, frames, b);
+    stream_close(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;
-    }
-    
-    /* [FIX] 将视频帧(NALU)封装为PS流后再推; 原pack_h264_to_ps从未被调用 */
-    int ps_len = pack_h264_to_ps(session, (const uint8_t*)frame->data, frame->data_size);
-    if (ps_len < 0) {
-        LOG_WARN("PS pack failed for stream ID=%d", session->stream_id);
-        return FAILURE;
-    }
-
-    RTMPPushContext* ctx = (RTMPPushContext*)session->internal_handle;
-    if (ctx && ctx->socket_fd >= 0) {
-        /* 通过RTMP发送PS数据(实际实现中使用zlmediakit API或FFmpeg) */
-    }
-
-    return SUCCESS;
-}
-
-StreamSession* stream_find_by_channel(const char* device_id, int channel) {
-    if (device_id == NULL) return NULL;
-    StreamSession* found = NULL;
-    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) {
-            found = g_sessions[i];
-            break;
-        }
-    }
-    pthread_mutex_unlock(&g_session_mutex);
-    return found;
-}
-
-int stream_stop_channel(const char* device_id, int channel) {
-    StreamSession* sess = stream_find_by_channel(device_id, channel);
-    if (sess != NULL) {
-        stream_stop_push(sess);
-        return SUCCESS;
-    }
-    return NOT_FOUND;
-}
-
-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);
-}
-
-StreamSession* stream_get_session(int stream_id) {
-    /* find_session 的公共封装, 供上层按ID查询 */
-    return find_session(stream_id);
-}
-
-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;
-}
+void stream_cleanup(void){ stream_stop_listen(); }

src/utils.c

@@ -1,140 +0,0 @@
-#include "common.h"
-#include <ctype.h>
-#include <sys/time.h>
-#include <sys/stat.h>
-#include <sys/types.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);
-}

systemd/hikvision-isup.service

@@ -0,0 +1,26 @@
+# Raspberry Pi 5 (Bookworm / systemd) service unit.
+# install: sudo cp systemd/hikvision-isup.service /etc/systemd/system/
+#          sudo systemctl daemon-reload && sudo systemctl enable --now hikvision-isup
+[Unit]
+Description=Hikvision ISUP5.0 device client (Pi5)
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+# real production build (needs aarch64 libHCNetSDK.so under ./libs)
+WorkingDirectory=/opt/hikvision-isup-client
+ExecStart=/opt/hikvision-isup-client/build/hikvision-isup-client-aarch64-real -c /opt/hikvision-isup-client/config.ini
+Restart=on-failure
+RestartSec=5
+# ISUP/Ehome device registration may bind ephemeral ports; keep it non-root
+User=pi
+Group=pi
+LimitNOFILE=65535
+# Pi5 8GB: cap RSS well under memory; bump if more channels added
+MemoryMax=1G
+ProtectSystem=full
+ReadWritePaths=/opt/hikvision-isup-client
+
+[Install]
+WantedBy=multi-user.target