fix():添加RTMP推流（未完成）

王鑫
1 parent f375c1c2
Showing 21 changed files with 4225 additions and 78 deletions
.claude/settings.local.json
src/main/java/com/genersoft/iot/vmp/jtt1078/publisher/Channel.java
src/main/java/com/genersoft/iot/vmp/jtt1078/publisher/FFmpegPublisher.java
src/main/java/com/genersoft/iot/vmp/jtt1078/publisher/IStreamPublisher.java
src/main/java/com/genersoft/iot/vmp/jtt1078/publisher/NativeRtmpPublisher.java
src/main/java/com/genersoft/iot/vmp/jtt1078/publisher/NettyRtmpPublisher.java
src/main/java/com/genersoft/iot/vmp/jtt1078/publisher/PublishManager.java
src/main/java/com/genersoft/iot/vmp/jtt1078/publisher/StreamPublisherFactory.java
src/main/java/com/genersoft/iot/vmp/jtt1078/rtmp/Amf0Util.java
src/main/java/com/genersoft/iot/vmp/jtt1078/rtmp/NettyRtmpClient.java
src/main/java/com/genersoft/iot/vmp/jtt1078/rtmp/RtmpChunkWriter.java
src/main/java/com/genersoft/iot/vmp/jtt1078/rtmp/RtmpConnection.java
src/main/java/com/genersoft/iot/vmp/jtt1078/rtmp/RtmpHandshakeHandler.java
src/main/java/com/genersoft/iot/vmp/jtt1078/server/Jtt1078Handler.java
src/main/java/com/genersoft/iot/vmp/jtt1078/subscriber/StreamSwitchLogAnalyzer.java
src/main/java/com/genersoft/iot/vmp/media/zlm/ZLMRESTfulUtils.java
src/main/java/com/genersoft/iot/vmp/vmanager/jt1078/platform/StreamSwitchMonitorController.java
src/main/resources/app-jt1078-em.properties
src/main/resources/app.properties
src/main/resources/logback-spring.xml
+{
+  "permissions": {
+    "allow": [
+      "Bash(mvn compile:*)"
+    ]
+  }
+}
 package com.genersoft.iot.vmp.jtt1078.publisher;
 import com.genersoft.iot.vmp.jtt1078.codec.AudioCodec;
+import com.genersoft.iot.vmp.jtt1078.codec.MP3Encoder;
 import com.genersoft.iot.vmp.jtt1078.entity.Media;
 import com.genersoft.iot.vmp.jtt1078.entity.MediaEncoding;
+import com.genersoft.iot.vmp.jtt1078.flv.AudioTag;
+import com.genersoft.iot.vmp.jtt1078.flv.FlvAudioTagEncoder;
 import com.genersoft.iot.vmp.jtt1078.flv.FlvEncoder;
-import com.genersoft.iot.vmp.jtt1078.subscriber.RTMPPublisher;
 import com.genersoft.iot.vmp.jtt1078.subscriber.Subscriber;
 import com.genersoft.iot.vmp.jtt1078.subscriber.VideoSubscriber;
+import com.genersoft.iot.vmp.jtt1078.util.ByteBufUtils;
 import com.genersoft.iot.vmp.jtt1078.util.ByteHolder;
 import com.genersoft.iot.vmp.jtt1078.util.Configs;
+import com.genersoft.iot.vmp.jtt1078.util.FLVUtils;
+import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import org.apache.commons.lang3.StringUtils;
 import org.slf4j.Logger;
@@ -26,8 +31,8 @@ public class Channel
     ConcurrentLinkedQueue<Subscriber> subscribers;
-    // [恢复] FFmpeg 推流进程管理器
-    RTMPPublisher rtmpPublisher;
+    // [修改] 使用IStreamPublisher接口，通过工厂创建具体的推流器
+    IStreamPublisher streamPublisher;
     String tag;
     boolean publishing;
@@ -36,6 +41,14 @@ public class Channel
     FlvEncoder flvEncoder;
     private long firstTimestamp = -1;
+    /** 相对时间戳（用于RTMP发送） - 与jtt1078-video-server保持一致 */
+    private int videoTimestamp = 0;
+    private long lastVideoTimeOffset = -1;  // 初始值-1表示未初始化，避免与有效timeoffset混淆
+
+    /** 相对时间戳（用于RTMP发送音频） */
+    private int audioTimestamp = 0;
+    private long lastAudioTimeOffset = -1;  // 初始值-1表示未初始化，避免与有效timeoffset混淆
+
     // ========== 新增：视频参数检测和FFmpeg自动重启相关 ==========
     /** 上一次接收到的SPS哈希值，用于检测视频参数变化 */
@@ -56,6 +69,16 @@ public class Channel
     /** 视频参数信息 */
     private volatile VideoParamInfo currentVideoParam = new VideoParamInfo();
+    /** 是否已发送视频Sequence Header（用于RTMP推流） */
+    private boolean videoHeaderSentForRtmp = false;
+
+    /** 是否已发送FLV Header（用于RTMP推流） */
+    private boolean flvHeaderSentForRtmp = false;
+
+    /** 音频编码器（用于RTMP推流） */
+    private MP3Encoder mp3Encoder;
+    private FlvAudioTagEncoder audioTagEncoder;
+
     /** 视频参数内部类 */
     private static class VideoParamInfo {
         int width = 0;
@@ -76,14 +99,16 @@ public class Channel
         this.flvEncoder = new FlvEncoder(true, true);
         this.buffer = new ByteHolder(2048 * 100);
-        // [恢复] 启动 FFmpeg 进程
-        // 只要配置了 rtmp.url，就启动 FFmpeg 去拉取当前的 HTTP 流并转码推送
+        // [修改] 使用工厂创建推流器
+        // 根据配置决定创建FFmpeg推流器还是原生RTMP推流器
         String rtmpUrl = Configs.get("rtmp.url");
         if (StringUtils.isNotBlank(rtmpUrl))
         {
-            logger.info("[{}] 启动 FFmpeg 进程推流至: {}", tag, rtmpUrl);
-            rtmpPublisher = new RTMPPublisher(tag);
-            rtmpPublisher.start();
+            logger.info("[{}] 使用推流器工厂创建推流器...", tag);
+            streamPublisher = StreamPublisherFactory.create(tag);
+            logger.info("[{}] 推流器类型: {}", tag, streamPublisher.getType());
+            logger.info("[{}] 推流器描述: {}", tag, StreamPublisherFactory.getPublisherTypeDescription());
+            streamPublisher.start(tag);
         }
     }
@@ -113,10 +138,19 @@ public class Channel
     public void writeVideo(long sequence, long timeoffset, int payloadType, byte[] h264)
     {
-        if (firstTimestamp == -1) firstTimestamp = timeoffset;
+        if (firstTimestamp == -1) {
+            firstTimestamp = timeoffset;
+            logger.info("[{}] writeVideo: first timestamp set to {}, h264len={}", tag, timeoffset, h264.length);
+        }
         this.publishing = true;
         this.buffer.write(h264);
+        // 调试日志
+        if (logger.isDebugEnabled()) {
+            logger.debug("[{}] writeVideo called: seq={}, time={}, payloadType={}, h264len={}, buffer.size={}",
+                    tag, sequence, timeoffset, payloadType, h264.length, buffer.size());
+        }
+
         while (true)
         {
             byte[] nalu = readNalu();
@@ -138,6 +172,8 @@ public class Channel
                     waitingForIFrame.set(false);
                     // 重置FLV编码器
                     this.flvEncoder = new FlvEncoder(true, true);
+                    this.videoHeaderSentForRtmp = false;
+                    this.flvHeaderSentForRtmp = false;
                     firstTimestamp = timeoffset;
                 } else {
                     // 跳过非I帧数据
@@ -149,7 +185,12 @@ public class Channel
             // FFmpeg 通过 HTTP 读取这些 FLV Tag
             byte[] flvTag = this.flvEncoder.write(nalu, (int) (timeoffset - firstTimestamp));
-            if (flvTag == null) continue;
+            if (flvTag == null) {
+                logger.debug("[{}] FlvEncoder.write returned null, skipping. nalType=0x{}", tag, Integer.toHexString(nalType));
+                continue;
+            }
+
+            logger.debug("[{}] FlvEncoder.write returned flvTag length={}, nalType=0x{}", tag, flvTag.length, Integer.toHexString(nalType));
             // 广播给所有的观众
             broadcastVideo(timeoffset, flvTag);
@@ -157,59 +198,39 @@ public class Channel
     }
     /**
-     * 检查SPS变化并处理FFmpeg重启
+     * 检查SPS变化并处理推流器
+     *
+     * 根据推流器类型决定处理方式：
+     * - FFmpeg推流器：重启FFmpeg进程（因为FFmpeg使用-vcodec copy无法感知SPS变化）
+     * - 原生RTMP推流器：立即发送新的AVC Sequence Header（无缝切换，0中断）
      */
     private synchronized void checkAndHandleSPSChange(byte[] nalu) {
         int currentHash = Arrays.hashCode(nalu);
         if (lastSPSHash != 0 && currentHash != lastSPSHash) {
             // SPS变化了，说明视频参数发生了变化
-            // 注意：即使解析出来的分辨率/帧率相同，SPS的其它变化（如profile、level、VUI参数等）也会导致解码问题
-            // 因此：只要SPS哈希变化，就重启FFmpeg
             // 解析新的视频参数（仅用于日志显示）
             VideoParamInfo newParam = parseVideoParam(nalu);
             VideoParamInfo oldParam = currentVideoParam;
-            logger.info("[{}] ====== 检测到SPS变化，需要重启FFmpeg ======", tag);
+            logger.info("[{}] ====== 检测到SPS变化 ======", tag);
             logger.info("[{}] 旧参数: {}", tag, oldParam);
             logger.info("[{}] 新参数: {}", tag, newParam);
             logger.info("[{}] SPS哈希变化: {} -> {}", tag,
                     Integer.toHexString(lastSPSHash),
                     Integer.toHexString(currentHash));
-            // 检查冷却时间
-            long now = System.currentTimeMillis();
-            long timeSinceLastRestart = now - lastRestartTime.get();
+            // 判断推流器类型
+            boolean isNativeRtmp = (streamPublisher != null && "native".equals(streamPublisher.getType()));
-            if (timeSinceLastRestart < RESTART_COOLDOWN_MS) {
-                logger.warn("[{}] FFmpeg重启过于频繁（距上次{}ms），跳过本次重启",
-                        tag, timeSinceLastRestart);
-                // 即使跳过重启，仍需更新SPS哈希
-                lastSPSHash = currentHash;
-                currentVideoParam = newParam;
-                return;
+            if (isNativeRtmp) {
+                // 原生RTMP模式：立即发送新的AVC Sequence Header（无缝切换）
+                handleSPSChangeForNativeRtmp(nalu, newParam);
+            } else {
+                // FFmpeg模式：重启FFmpeg进程
+                handleSPSChangeForFFmpeg(newParam);
             }
-
-            logger.info("[{}] ====== 准备重启FFmpeg ======", tag);
-            logger.info("[{}] 原因: SPS参数变化（可能包含分辨率、帧率、profile、level等）", tag);
-            logger.info("[{}] 预计中断时间: 1-2秒", tag);
-
-            // 标记需要重启
-            ffmpegNeedRestart.set(true);
-
-            // 立即触发重启（异步执行，避免阻塞）
-            final String currentTag = tag;
-            Thread restartThread = new Thread(() -> {
-                try {
-                    logger.info("[{}] SPS变化检测到，立即触发FFmpeg重启...", currentTag);
-                    restartRtmpPublisher();
-                } catch (Exception e) {
-                    logger.error("[{}] 触发FFmpeg重启失败: {}", currentTag, e.getMessage(), e);
-                }
-            }, "FFmpeg-Restart-" + tag);
-            restartThread.setDaemon(true);
-            restartThread.start();
         }
         // 更新SPS哈希和视频参数
@@ -218,6 +239,104 @@ public class Channel
     }
     /**
+     * 处理SPS变化（原生RTMP模式）
+     * 立即发送新的AVC Sequence Header，实现无缝切换
+     */
+    private void handleSPSChangeForNativeRtmp(byte[] nalu, VideoParamInfo newParam) {
+        logger.info("[{}] ====== 原生RTMP模式：立即发送新的AVC Sequence Header ======", tag);
+        logger.info("[{}] 码流切换将无缝完成，无需中断", tag);
+
+        // 检查冷却时间
+        long now = System.currentTimeMillis();
+        long timeSinceLastRestart = now - lastRestartTime.get();
+
+        if (timeSinceLastRestart < RESTART_COOLDOWN_MS) {
+            logger.warn("[{}] 发送AVC Sequence Header过于频繁（距上次{}ms），跳过",
+                    tag, timeSinceLastRestart);
+            return;
+        }
+
+        if (streamPublisher != null && streamPublisher.isConnected()) {
+            // 提取SPS和PPS（从FlvEncoder获取）
+            byte[] sps = extractSPSFromNalu(nalu);
+            byte[] pps = extractPPSFromBuffer();
+
+            // 更新推流器的SPS/PPS缓存
+            if (streamPublisher instanceof NativeRtmpPublisher) {
+                ((NativeRtmpPublisher) streamPublisher).updateSPSPPS(sps, pps);
+            }
+
+            // 触发发送新的AVC Sequence Header
+            streamPublisher.sendAVCSequenceHeader();
+            lastRestartTime.set(now);
+
+            logger.info("[{}] ====== AVC Sequence Header已发送，码流切换完成 ======", tag);
+        } else {
+            logger.warn("[{}] 推流器未连接，无法发送AVC Sequence Header", tag);
+        }
+    }
+
+    /**
+     * 处理SPS变化（FFmpeg模式）
+     * 重启FFmpeg进程
+     */
+    private void handleSPSChangeForFFmpeg(VideoParamInfo newParam) {
+        // 检查冷却时间
+        long now = System.currentTimeMillis();
+        long timeSinceLastRestart = now - lastRestartTime.get();
+
+        if (timeSinceLastRestart < RESTART_COOLDOWN_MS) {
+            logger.warn("[{}] FFmpeg重启过于频繁（距上次{}ms），跳过本次重启",
+                    tag, timeSinceLastRestart);
+            return;
+        }
+
+        logger.info("[{}] ====== FFmpeg模式：准备重启FFmpeg ======", tag);
+        logger.info("[{}] 原因: SPS参数变化（可能包含分辨率、帧率、profile、level等）", tag);
+        logger.info("[{}] 预计中断时间: 1-2秒", tag);
+
+        // 标记需要重启
+        ffmpegNeedRestart.set(true);
+
+        // 立即触发重启（异步执行，避免阻塞）
+        final String currentTag = tag;
+        Thread restartThread = new Thread(() -> {
+            try {
+                logger.info("[{}] SPS变化检测到，立即触发FFmpeg重启...", currentTag);
+                restartRtmpPublisher();
+            } catch (Exception e) {
+                logger.error("[{}] 触发FFmpeg重启失败: {}", currentTag, e.getMessage(), e);
+            }
+        }, "FFmpeg-Restart-" + tag);
+        restartThread.setDaemon(true);
+        restartThread.start();
+    }
+
+    /**
+     * 从NALU中提取SPS
+     */
+    private byte[] extractSPSFromNalu(byte[] nalu) {
+        // NALU格式: [00 00 00 01 xx] + SPS数据
+        // SPS从第5个字节开始
+        if (nalu.length > 5) {
+            byte[] sps = new byte[nalu.length - 4];
+            System.arraycopy(nalu, 4, sps, 0, sps.length);
+            return sps;
+        }
+        return nalu;
+    }
+
+    /**
+     * 从buffer中提取PPS
+     * 注意：这是一个简化实现，实际可能需要更复杂的逻辑
+     */
+    private byte[] extractPPSFromBuffer() {
+        // 在实际实现中，应该从buffer中查找PPS NALU（NAL类型为8）
+        // 这里返回null，让chunkWriter使用缓存的PPS
+        return null;
+    }
+
+    /**
      * 解析H.264 SPS获取视频参数
      */
     private VideoParamInfo parseVideoParam(byte[] sps) {
@@ -332,15 +451,15 @@ public class Channel
             // 1. 标记等待I帧
             waitingForIFrame.set(true);
-            // 2. 关闭旧的FFmpeg进程
-            logger.info("[{}] 步骤1: 关闭旧FFmpeg进程...", tag);
-            if (rtmpPublisher != null) {
+            // 2. 关闭旧的推流器
+            logger.info("[{}] 步骤1: 关闭旧推流器...", tag);
+            if (streamPublisher != null) {
                 try {
-                    rtmpPublisher.close();
+                    streamPublisher.close();
                 } catch (Exception e) {
-                    logger.warn("[{}] 关闭旧FFmpeg进程时出错: {}", tag, e.getMessage());
+                    logger.warn("[{}] 关闭旧推流器时出错: {}", tag, e.getMessage());
                 }
-                rtmpPublisher = null;
+                streamPublisher = null;
             }
             // 3. 等待FFmpeg进程完全关闭
@@ -351,18 +470,25 @@ public class Channel
             logger.info("[{}] 步骤3: 清空视频缓冲区...", tag);
             buffer.clear();
             firstTimestamp = -1;
+            // 重置相对时间戳
+            videoTimestamp = 0;
+            lastVideoTimeOffset = -1;
+            audioTimestamp = 0;
+            lastAudioTimeOffset = -1;
             // 5. 重置FLV编码器
             logger.info("[{}] 步骤4: 重置FLV编码器...", tag);
             flvEncoder = new FlvEncoder(true, true);
+            videoHeaderSentForRtmp = false;
+            flvHeaderSentForRtmp = false;
-            // 6. 重新启动FFmpeg进程
-            logger.info("[{}] 步骤5: 启动新FFmpeg进程...", tag);
+            // 6. 重新启动推流器
+            logger.info("[{}] 步骤5: 启动新推流器...", tag);
             String rtmpUrl = Configs.get("rtmp.url");
             if (StringUtils.isNotBlank(rtmpUrl)) {
-                rtmpPublisher = new RTMPPublisher(tag);
-                rtmpPublisher.start();
-                logger.info("[{}] 新FFmpeg进程已启动", tag);
+                streamPublisher = StreamPublisherFactory.create(tag);
+                streamPublisher.start(tag);
+                logger.info("[{}] 新推流器已启动, 类型: {}", tag, streamPublisher.getType());
             } else {
                 logger.warn("[{}] 未配置rtmp.url，跳过启动", tag);
             }
@@ -374,11 +500,11 @@ public class Channel
             logger.info("[{}] 请等待1-2秒让FFmpeg完成初始化...", tag);
         } catch (Exception e) {
-            logger.error("[{}] 重启FFmpeg失败: {}", tag, e.getMessage(), e);
+            logger.error("[{}] 重启推流器失败: {}", tag, e.getMessage(), e);
             waitingForIFrame.set(false);
             ffmpegNeedRestart.set(false);
-            // 确保rtmpPublisher被清空
-            rtmpPublisher = null;
+            // 确保streamPublisher被清空
+            streamPublisher = null;
         }
     }
@@ -433,6 +559,72 @@ public class Channel
     public void broadcastVideo(long timeoffset, byte[] flvTag)
     {
+        // ========== 计算相对时间戳（与jtt1078-video-server保持一致）==========
+        // 初始化lastVideoTimeOffset
+        if (lastVideoTimeOffset == -1) {
+            // 首次设置，不累加时间戳
+            lastVideoTimeOffset = timeoffset;
+        } else {
+            // 计算增量并累加到videoTimestamp
+            videoTimestamp += (int)(timeoffset - lastVideoTimeOffset);
+            lastVideoTimeOffset = timeoffset;
+        }
+
+        // ========== 发送Sequence Header（仅RTMP推流需要）==========
+        // 与jtt1078-video-server的VideoSubscriber保持一致：
+        // 当videoReady()首次为true时，发送Sequence Header FLV tag（时间戳为0）
+        if (flvEncoder.videoReady()) {
+            // 先发送 FLV Header（与jtt1078-video-server一致）
+            if (!flvHeaderSentForRtmp) {
+                byte[] flvHeader = flvEncoder.getHeader().getBytes();
+                logger.info("[{}] >>> [RTMP发送] FLV Header, length={}, streamPublisher={}, connected={}",
+                        tag, flvHeader != null ? flvHeader.length : 0,
+                        streamPublisher != null, streamPublisher != null && streamPublisher.isConnected());
+                if (flvHeader != null && flvHeader.length > 0 && streamPublisher != null && streamPublisher.isConnected()) {
+                    streamPublisher.sendVideoData(flvHeader, 0);
+                    logger.info("[{}] >>> [RTMP发送] FLV Header 已发送", tag);
+                }
+                flvHeaderSentForRtmp = true;
+            }
+
+            // 再发送 Video Header (AVC Sequence Header)
+            if (!videoHeaderSentForRtmp) {
+                byte[] videoHeader = flvEncoder.getVideoHeader().getBytes();
+                logger.info("[{}] >>> [RTMP发送] Video Header (AVC Sequence Header), length={}, videoReady={}",
+                        tag, videoHeader != null ? videoHeader.length : 0, flvEncoder.videoReady());
+                if (videoHeader != null && videoHeader.length > 0) {
+                    FLVUtils.resetTimestamp(videoHeader, 0);
+                    if (streamPublisher != null && streamPublisher.isConnected()) {
+                        streamPublisher.sendVideoData(videoHeader, 0);
+                        logger.info("[{}] >>> [RTMP发送] Video Header 发送完成", tag);
+                    }
+                }
+                videoHeaderSentForRtmp = true;
+            }
+        }
+
+        // 重置FLV Tag中的时间戳为累积的相对时间戳
+        if (flvTag != null) {
+            FLVUtils.resetTimestamp(flvTag, videoTimestamp);
+        }
+
+        // 发送给native RTMP推流器（如果有）
+        if (streamPublisher == null) {
+            logger.info("[{}] broadcastVideo: streamPublisher is null", tag);
+        } else if (!streamPublisher.isConnected()) {
+            logger.info("[{}] broadcastVideo: streamPublisher not connected, connected={}", tag, streamPublisher.isConnected());
+        } else {
+            try {
+                if (flvTag != null && flvTag.length > 0) {
+                    logger.debug("[{}] >>> [RTMP发送] Video Frame, length={}, videoTimestamp={}", tag, flvTag.length, videoTimestamp);
+                    streamPublisher.sendVideoData(flvTag, videoTimestamp);
+                }
+            } catch (Exception e) {
+                logger.error("[{}] 发送视频数据到RTMP失败: {}", tag, e.getMessage());
+            }
+        }
+
+        // 广播给HTTP订阅者（传递原始timeoffset，保持兼容性）
         for (Subscriber subscriber : subscribers)
         {
             subscriber.onVideoData(timeoffset, flvTag, flvEncoder);
@@ -441,6 +633,58 @@ public class Channel
     public void broadcastAudio(long timeoffset, byte[] flvTag)
     {
+        // ========== 暂时禁用RTMP音频发送，只广播给HTTP订阅者 ==========
+        // [TODO] 后续需要实现AAC编码后再启用音频RTMP发送
+        /*
+        if (streamPublisher != null && streamPublisher.isConnected() && flvTag != null && flvTag.length > 0) {
+            try {
+                // 初始化音频编码器（如果尚未初始化）
+                if (mp3Encoder == null) {
+                    mp3Encoder = new MP3Encoder();
+                }
+                if (audioTagEncoder == null) {
+                    audioTagEncoder = new FlvAudioTagEncoder();
+                }
+
+                // 音频时间戳处理（与视频类似）
+                if (lastAudioTimeOffset == -1) {
+                    // 首次设置，不累加时间戳
+                    lastAudioTimeOffset = timeoffset;
+                } else {
+                    audioTimestamp += (int)(timeoffset - lastAudioTimeOffset);
+                    lastAudioTimeOffset = timeoffset;
+                }
+
+                // PCM编码为MP3
+                byte[] mp3Data = mp3Encoder.encode(flvTag);
+                if (mp3Data == null || mp3Data.length == 0) {
+                    logger.debug("[{}] MP3编码失败，跳过该音频帧", tag);
+                    // 仍然广播给HTTP订阅者
+                    for (Subscriber subscriber : subscribers) {
+                        subscriber.onAudioData(timeoffset, flvTag, flvEncoder);
+                    }
+                    return;
+                }
+
+                // 创建音频标签 (format=MP3, rate=22kHz, size=16bit, type=stereo)
+                AudioTag audioTag = new AudioTag(0, mp3Data.length + 1, AudioTag.MP3, (byte) 2, (byte) 1, (byte) 1, mp3Data);
+
+                // 编码为FLV音频标签
+                ByteBuf audioBuf = audioTagEncoder.encode(audioTag);
+                byte[] audioFlvTag = ByteBufUtils.readReadableBytes(audioBuf);
+
+                // 重置时间戳
+                FLVUtils.resetTimestamp(audioFlvTag, audioTimestamp);
+
+                streamPublisher.sendVideoData(audioFlvTag, audioTimestamp);
+                logger.debug("[{}] >>> [RTMP发送] Audio Frame, length={}, audioTimestamp={}", tag, audioFlvTag.length, audioTimestamp);
+            } catch (Exception e) {
+                logger.error("[{}] 发送音频数据到RTMP失败: {}", tag, e.getMessage());
+            }
+        }
+        */
+
+        // 广播给HTTP订阅者
         for (Subscriber subscriber : subscribers)
         {
             subscriber.onAudioData(timeoffset, flvTag, flvEncoder);
@@ -472,11 +716,11 @@ public class Channel
             itr.remove();
         }
-        // 关闭 FFmpeg 进程
-        if (rtmpPublisher != null) {
-            logger.info("[{}] 关闭FFmpeg推流进程...", tag);
-            rtmpPublisher.close();
-            rtmpPublisher = null;
+        // 关闭推流器
+        if (streamPublisher != null) {
+            logger.info("[{}] 关闭推流器...", tag);
+            streamPublisher.close();
+            streamPublisher = null;
         }
         logger.info("[{}] Channel已关闭", tag);
@@ -497,9 +741,12 @@ public class Channel
                 if (i == 0) continue;
                 byte[] nalu = new byte[i];
                 buffer.sliceInto(nalu, i);
+                logger.debug("[{}] readNalu: found NALU at i={}, len={}, nalType=0x{}",
+                        tag, i, nalu.length, nalu.length > 4 ? String.format("%02x", nalu[4] & 0x1F) : "N/A");
                 return nalu;
             }
         }
+        logger.debug("[{}] readNalu: no start code found, buffer.size={}", tag, buffer.size());
         return null;
     }
 }
+package com.genersoft.iot.vmp.jtt1078.publisher;
+
+import com.genersoft.iot.vmp.jtt1078.util.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.Closeable;
+import java.io.InputStream;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * FFmpeg 推流器 (仅处理视频直播流)
+ *
+ * 实现了IStreamPublisher接口，支持通过工厂创建
+ *
+ * 修改记录：
+ * 1. 实现IStreamPublisher接口，支持工厂模式
+ * 2. 添加详细的启动和关闭日志，便于排查问题
+ * 3. 优化关闭逻辑，确保FFmpeg进程被正确终止
+ * 4. 添加FFmpeg输出日志监控
+ * 5. 兼容Java 8
+ */
+public class FFmpegPublisher extends Thread implements IStreamPublisher
+{
+    static Logger logger = LoggerFactory.getLogger(FFmpegPublisher.class);
+
+    String tag = null;
+    Process process = null;
+    private volatile boolean running = true;
+    private volatile boolean connected = false;
+
+    /** FFmpeg路径 */
+    private String ffmpegPath = null;
+
+    /** 目标RTMP地址 */
+    private String rtmpUrl = null;
+
+    /** FFmpeg命令格式标志 */
+    private String formatFlag = null;
+
+    /** 进程启动时间 */
+    private long processStartTime = 0;
+
+    /** 推流器类型标识 */
+    private static final String PUBLISHER_TYPE = "ffmpeg";
+
+    public FFmpegPublisher(String tag)
+    {
+        this.tag = tag;
+        this.setName("FFmpegPublisher-" + tag);
+        this.setDaemon(true);
+    }
+
+    @Override
+    public void start(String tag) {
+        this.start();
+    }
+
+    @Override
+    public void run()
+    {
+        InputStream stderr = null;
+        InputStream stdout = null;
+        int len = -1;
+        byte[] buff = new byte[512];
+        boolean debugMode = "on".equalsIgnoreCase(Configs.get("debug.mode"));
+
+        try
+        {
+            // 获取FFmpeg配置
+            String sign = "41db35390ddad33f83944f44b8b75ded";
+            rtmpUrl = Configs.get("rtmp.url").replaceAll("\\{TAG\\}", tag).replaceAll("\\{sign\\}",sign);
+            ffmpegPath = Configs.get("ffmpeg.path");
+
+            // 自动判断协议格式
+            formatFlag = "";
+            if (rtmpUrl.startsWith("rtsp://")) {
+                formatFlag = "-f rtsp";
+            } else if (rtmpUrl.startsWith("rtmp://")) {
+                formatFlag = "-f flv";
+            }
+
+            // 构造FFmpeg命令
+            String cmd = String.format("%s -i http://127.0.0.1:%d/video/%s -vcodec copy -acodec aac %s %s",
+                    ffmpegPath,
+                    Configs.getInt("server.http.port", 3333),
+                    tag,
+                    formatFlag,
+                    rtmpUrl
+            );
+
+            logger.info("===========================================");
+            logger.info("[{}] ====== FFmpeg推流任务启动 ======", tag);
+            logger.info("[{}] FFmpeg路径: {}", tag, ffmpegPath);
+            logger.info("[{}] 目标地址: {}", tag, rtmpUrl);
+            logger.info("[{}] 完整命令: {}", tag, cmd);
+            logger.info("[{}] HTTP端口: {}", tag, Configs.getInt("server.http.port", 3333));
+            logger.info("[{}] 源流地址: http://127.0.0.1:{}/video/{}", tag, Configs.getInt("server.http.port", 3333), tag);
+            logger.info("[{}] 启动时间: {}", tag, new java.util.Date());
+            logger.info("===========================================");
+
+            // 执行FFmpeg命令
+            process = Runtime.getRuntime().exec(cmd);
+            processStartTime = System.currentTimeMillis();
+            connected = true;
+
+            // 记录进程启动信息（Java 8兼容方式）
+            logger.info("[{}] FFmpeg进程已启动", tag);
+
+            stderr = process.getErrorStream();
+            stdout = process.getInputStream();
+
+            // 启动一个线程消费 stdout，防止缓冲区满导致进程阻塞
+            final InputStream finalStdout = stdout;
+            Thread stdoutConsumer = new Thread(() -> {
+                try {
+                    byte[] buffer = new byte[512];
+                    int count = 0;
+                    while (running && finalStdout.read(buffer) > -1) {
+                        count++;
+                        // 每1000次读取才打印一次（避免刷屏）
+                        if (debugMode && count % 1000 == 0) {
+                            logger.debug("[{}] FFmpeg stdout消费中... count: {}", tag, count);
+                        }
+                    }
+                    logger.info("[{}] FFmpeg stdout消费结束, 共消费{}次", tag, count);
+                } catch (Exception e) {
+                    // 忽略异常
+                }
+            }, "FFmpeg-stdout-" + tag);
+            stdoutConsumer.setDaemon(true);
+            stdoutConsumer.start();
+
+            // 消费 stderr 日志流
+            StringBuilder errorLog = new StringBuilder();
+            int errorCount = 0;
+            while (running && (len = stderr.read(buff)) > -1)
+            {
+                if (debugMode) {
+                    System.out.print(new String(buff, 0, len));
+                }
+
+                // 收集错误日志（便于排查问题）
+                errorLog.append(new String(buff, 0, len));
+                errorCount++;
+
+                // 每100条错误日志打印一次摘要
+                if (errorCount % 100 == 0) {
+                    String lastError = errorLog.length() > 500
+                        ? errorLog.substring(errorLog.length() - 500)
+                        : errorLog.toString();
+                    logger.debug("[{}] FFmpeg错误日志摘要: {}", tag, lastError);
+                }
+            }
+
+            // 进程退出处理
+            int exitCode = process.waitFor();
+            long runDuration = System.currentTimeMillis() - processStartTime;
+            connected = false;
+            logger.warn("===========================================");
+            logger.warn("[{}] ====== FFmpeg推流任务结束 ======", tag);
+            logger.warn("[{}] 退出代码: {}", tag, exitCode);
+            logger.warn("[{}] 运行时间: {} ms", tag, runDuration);
+            logger.warn("[{}] 错误日志条数: {}", tag, errorCount);
+
+            // 分析退出原因
+            if (exitCode == 0) {
+                logger.info("[{}] FFmpeg正常退出", tag);
+            } else if (exitCode == -1 || exitCode == 255) {
+                logger.warn("[{}] FFmpeg被信号终止 (exitCode={})", tag, exitCode);
+            } else {
+                // 保存最后一段错误日志
+                String lastError = errorLog.length() > 1000
+                    ? errorLog.substring(errorLog.length() - 1000)
+                    : errorLog.toString();
+                logger.error("[{}] FFmpeg异常退出, 最后错误日志:\n{}", tag, lastError);
+            }
+            logger.warn("===========================================");
+
+        }
+        catch(InterruptedException ex)
+        {
+            logger.info("[{}] FFmpegPublisher被中断: {}", tag, ex.getMessage());
+            Thread.currentThread().interrupt();
+        }
+        catch(Exception ex)
+        {
+            logger.error("[{}] FFmpegPublisher异常: {}", tag, ex);
+        }
+        finally
+        {
+            connected = false;
+            // 确保所有流都被关闭
+            closeQuietly(stderr);
+            closeQuietly(stdout);
+            if (process != null) {
+                closeQuietly(process.getInputStream());
+                closeQuietly(process.getOutputStream());
+                closeQuietly(process.getErrorStream());
+            }
+            logger.info("[{}] FFmpegPublisher资源已释放", tag);
+        }
+    }
+
+    /**
+     * 关闭FFmpeg推流
+     * 优化关闭逻辑，确保进程被正确终止（Java 8兼容）
+     */
+    @Override
+    public void close()
+    {
+        logger.info("[{}] ====== 开始关闭FFmpeg推流 ======", tag);
+        logger.info("[{}] 关闭请求时间: {}", tag, new java.util.Date());
+
+        try {
+            // 设置停止标志
+            running = false;
+            connected = false;
+
+            if (process != null) {
+                long runDuration = processStartTime > 0 ? System.currentTimeMillis() - processStartTime : 0;
+                logger.info("[{}] 正在终止FFmpeg进程... (已运行{}ms)", tag, runDuration);
+
+                // 先尝试正常终止
+                process.destroy();
+
+                // 等待最多3秒
+                boolean exited = process.waitFor(3, TimeUnit.SECONDS);
+
+                if (!exited) {
+                    logger.warn("[{}] FFmpeg进程未能在3秒内正常退出，开始强制终止...", tag);
+
+                    // 强制终止（Java 8的方式）
+                    process.destroyForcibly();
+
+                    // 再等待2秒
+                    try {
+                        exited = process.waitFor(2, TimeUnit.SECONDS);
+                    } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt();
+                    }
+                    if (!exited) {
+                        logger.error("[{}] FFmpeg进程强制终止失败，可能存在资源泄漏", tag);
+                    } else {
+                        logger.info("[{}] FFmpeg进程已强制终止", tag);
+                    }
+                } else {
+                    int exitCode = process.exitValue();
+                    logger.info("[{}] FFmpeg进程已正常终止, 退出代码: {}", tag, exitCode);
+                }
+
+                // 检查是否需要杀掉残留进程
+                checkAndKillOrphanedProcesses();
+
+            } else {
+                logger.info("[{}] FFmpeg进程为空，无需关闭", tag);
+            }
+
+            logger.info("[{}] ====== FFmpeg推流已关闭 ======", tag);
+
+            // 中断线程（如果还在阻塞读取）
+            this.interrupt();
+
+            // 等待线程结束
+            this.join(2000);
+            if (this.isAlive()) {
+                logger.warn("[{}] FFmpegPublisher线程未能正常结束", tag);
+            }
+
+        } catch(Exception e) {
+            logger.error("[{}] 关闭FFmpegPublisher时出错: {}", tag, e);
+        }
+    }
+
+    /**
+     * 检查并杀掉可能残留的FFmpeg进程
+     * 某些情况下FFmpeg进程可能没有被正确回收
+     */
+    private void checkAndKillOrphanedProcesses() {
+        try {
+            // 根据FFmpeg命令特征查找残留进程
+            // 注意：这里只是记录日志，实际杀进程需要谨慎
+            logger.debug("[{}] 检查是否有FFmpeg残留进程...", tag);
+        } catch (Exception e) {
+            logger.debug("[{}] 检查残留进程时出错: {}", tag, e.getMessage());
+        }
+    }
+
+    /**
+     * 安全关闭流，忽略异常
+     */
+    private void closeQuietly(Closeable stream) {
+        if (stream != null) {
+            try {
+                stream.close();
+            } catch (Exception e) {
+                // 忽略
+            }
+        }
+    }
+
+    /**
+     * 发送FLV数据 - FFmpeg模式不需要此方法
+     * 数据通过HTTP接口由FFmpeg自动拉取
+     */
+    @Override
+    public void sendVideoData(byte[] flvData, int timestamp) {
+        // FFmpeg模式不需要实现此方法
+        // 数据通过HTTP接口由FFmpeg自动拉取
+    }
+
+    /**
+     * 发送AVC序列头 - FFmpeg模式不需要此方法
+     * FFmpeg模式下，SPS变化通过重启FFmpeg进程来解决
+     */
+    @Override
+    public void sendAVCSequenceHeader() {
+        // FFmpeg模式不需要实现此方法
+        // SPS变化时通过restartRtmpPublisher()重启FFmpeg解决
+        logger.debug("[{}] FFmpeg模式不需要sendAVCSequenceHeader", tag);
+    }
+
+    /**
+     * 获取推流状态
+     */
+    @Override
+    public boolean isConnected() {
+        return connected && this.isAlive() && process != null;
+    }
+
+    /**
+     * 获取推流器类型
+     */
+    @Override
+    public String getType() {
+        return PUBLISHER_TYPE;
+    }
+
+    /**
+     * 获取推流器信息（用于调试）
+     */
+    @Override
+    public String getStatus() {
+        if (process == null) {
+            return "FFmpeg进程未启动";
+        }
+        try {
+            long runDuration = processStartTime > 0 ? System.currentTimeMillis() - processStartTime : 0;
+            return String.format("FFmpeg推流器, 已运行%dms, 进程存活=%s, 连接状态=%s",
+                    runDuration, process.isAlive(), connected ? "已连接" : "未连接");
+        } catch (Exception e) {
+            return "获取FFmpeg状态失败: " + e.getMessage();
+        }
+    }
+
+    /**
+     * 获取FFmpeg进程信息（用于调试）
+     */
+    public String getProcessInfo() {
+        if (process == null) {
+            return "process is null";
+        }
+        try {
+            long runDuration = processStartTime > 0 ? System.currentTimeMillis() - processStartTime : 0;
+            return String.format("FFmpeg进程, 已运行%dms, alive=%s",
+                    runDuration, process.isAlive());
+        } catch (Exception e) {
+            return "获取进程信息失败: " + e.getMessage();
+        }
+    }
+}
+package com.genersoft.iot.vmp.jtt1078.publisher;
+
+/**
+ * 推流器接口
+ *
+ * 定义统一的推流器接口，支持多种推流实现（FFmpeg、原生RTMP等）
+ *
+ * 设计原则：
+ * 1. 简单明了，只定义核心方法
+ * 2. FFmpeg推流器实现时，sendAVCSequenceHeader为空操作
+ * 3. 原生RTMP推流器实现时，SPS变化通过sendAVCSequenceHeader立即生效
+ */
+public interface IStreamPublisher {
+
+    /**
+     * 启动推流
+     * @param tag 通道标识
+     */
+    void start(String tag);
+
+    /**
+     * 发送FLV视频数据
+     * @param flvData FLV Video Tag数据（包含PreviousTagSize和Video Tag）
+     * @param timestamp 时间戳（毫秒）
+     */
+    void sendVideoData(byte[] flvData, int timestamp);
+
+    /**
+     * 发送AVC序列头（SPS/PPS）
+     * 当检测到SPS变化时调用此方法
+     * FFmpeg推流器不需要实现此方法（因为重启FFmpeg即可）
+     * 原生RTMP推流器会立即发送新的AVC Sequence Header到RTMP服务器
+     */
+    void sendAVCSequenceHeader();
+
+    /**
+     * 关闭推流
+     * 应该释放所有资源，包括进程、Socket连接等
+     */
+    void close();
+
+    /**
+     * 检查是否连接中
+     * @return true表示推流器处于活跃状态
+     */
+    boolean isConnected();
+
+    /**
+     * 获取推流器类型
+     * @return "ffmpeg" 或 "native"
+     */
+    String getType();
+
+    /**
+     * 获取推流器信息（用于调试）
+     * @return 推流器状态描述
+     */
+    String getStatus();
+}
+package com.genersoft.iot.vmp.jtt1078.publisher;
+
+import com.genersoft.iot.vmp.jtt1078.rtmp.RtmpChunkWriter;
+import com.genersoft.iot.vmp.jtt1078.rtmp.RtmpConnection;
+import com.genersoft.iot.vmp.jtt1078.util.Configs;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * 原生Java RTMP推流器
+ *
+ * 实现了IStreamPublisher接口，使用原生Java实现RTMP协议推送
+ *
+ * 核心功能：
+ * 1. RTMP握手和连接
+ * 2. FLV数据到RTMP消息的转换
+ * 3. 断流检测和自动重连
+ * 4. 码流参数变化时无缝切换（发送新的SPS/PPS）
+ */
+public class NativeRtmpPublisher implements IStreamPublisher, Runnable {
+
+    static Logger logger = LoggerFactory.getLogger(NativeRtmpPublisher.class);
+
+    private String tag;
+    private volatile boolean connected = false;
+    private volatile boolean running = false;
+    private static final String PUBLISHER_TYPE = "native";
+
+    // RTMP连接配置
+    private String host;
+    private int port;
+    private String app;
+    private String tcUrl;
+    private String streamName;
+
+    // RTMP组件
+    private RtmpConnection connection;
+    private RtmpChunkWriter chunkWriter;
+
+    // 重连配置
+    private static final int MAX_RECONNECT_ATTEMPTS = 5;
+    private static final long INITIAL_RECONNECT_DELAY_MS = 1000;
+    private static final long MAX_RECONNECT_DELAY_MS = 16000;
+
+    private final AtomicInteger reconnectAttempts = new AtomicInteger(0);
+    private long lastReconnectTime = 0;
+
+    // 心跳检测
+    private static final long HEARTBEAT_INTERVAL_MS = 5000;
+    private long lastHeartbeatTime = 0;
+
+    // 线程
+    private Thread heartbeatThread;
+    private volatile Thread currentThread;
+
+    // SPS/PPS缓存（用于无缝切换）
+    private byte[] cachedSPS = null;
+    private byte[] cachedPPS = null;
+    private volatile boolean needSendNewSequenceHeader = false;
+
+    public NativeRtmpPublisher(String tag) {
+        this.tag = tag;
+        loadConfig();
+    }
+
+    /**
+     * 从配置加载RTMP连接参数
+     *
+     * 优先级：
+     * 1. rtmp.native.tcUrl (完整TCUrl配置)
+     * 2. rtmp.native.host/port/app (分离配置)
+     * 3. rtmp.url (兼容旧配置)
+     * 4. 默认值
+     */
+    private void loadConfig() {
+        // 优先使用原生RTMP配置
+        String configHost = Configs.get("rtmp.native.host");
+        String configPort = Configs.get("rtmp.native.port");
+        String configApp = Configs.get("rtmp.native.app");
+        String configTcUrl = Configs.get("rtmp.native.tcUrl");
+
+        // 如果有完整的tcUrl配置，直接使用
+        if (configTcUrl != null && !configTcUrl.isEmpty()) {
+            this.tcUrl = configTcUrl.replace("{TAG}", tag);
+            // 从tcUrl解析host和port
+            parseTcUrl(configTcUrl);
+            logger.info("[{}] 使用配置的tcUrl: {}", tag, this.tcUrl);
+            return;
+        }
+
+        // 如果有分离配置，使用分离配置
+        if (configHost != null && !configHost.isEmpty()) {
+            this.host = configHost;
+        } else {
+            this.host = "127.0.0.1";
+        }
+
+        if (configPort != null && !configPort.isEmpty()) {
+            this.port = Integer.parseInt(configPort);
+        } else {
+            this.port = 1935;
+        }
+
+        if (configApp != null && !configApp.isEmpty()) {
+            this.app = configApp;
+        } else {
+            this.app = "schedule";
+        }
+
+        // streamName = tag
+        this.streamName = tag;
+
+        // 从rtmp.url获取sign参数（参考FFmpegPublisher的处理方式）
+        String sign = "41db35390ddad33f83944f44b8b75ded";  // 默认sign
+        String rtmpUrl = Configs.get("rtmp.url");
+        if (rtmpUrl != null && rtmpUrl.contains("sign=")) {
+            int signStart = rtmpUrl.indexOf("sign=") + 5;
+            int signEnd = rtmpUrl.indexOf("&", signStart);
+            if (signEnd == -1) signEnd = rtmpUrl.length();
+            String extractedSign = rtmpUrl.substring(signStart, signEnd);
+            if (!extractedSign.isEmpty() && !"{sign}".equals(extractedSign)) {
+                sign = extractedSign;
+            }
+        }
+
+        // FFmpeg使用完整URL: rtmp://host:port/app/streamName?sign=xxx，ZLM也能正确解析
+        // 将streamName和sign包含在tcUrl中
+        this.tcUrl = String.format("rtmp://%s:%d/%s/%s?sign=%s", host, port, app, tag, sign);
+
+        logger.info("[{}] RTMP推流器配置: host={}, port={}, app={}, stream={}, tcUrl={}",
+                tag, host, port, app, streamName, tcUrl);
+    }
+
+    /**
+     * 从tcUrl解析host和port
+     */
+    private void parseTcUrl(String tcUrl) {
+        try {
+            // 移除sign参数
+            if (tcUrl.contains("?")) {
+                tcUrl = tcUrl.substring(0, tcUrl.indexOf("?"));
+            }
+
+            // 支持 rtmp://, rtsp://, http:// 等协议
+            String prefix = "://";
+            int prefixIndex = tcUrl.indexOf(prefix);
+            if (prefixIndex == -1) {
+                logger.warn("[{}] tcUrl没有有效的协议前缀: {}", tag, tcUrl);
+                return;
+            }
+
+            String afterPrefix = tcUrl.substring(prefixIndex + prefix.length());
+
+            // 分割host:port和path
+            int slashIndex = afterPrefix.indexOf("/");
+            String hostPort;
+            String path;
+            if (slashIndex == -1) {
+                hostPort = afterPrefix;
+                path = "";
+            } else {
+                hostPort = afterPrefix.substring(0, slashIndex);
+                path = afterPrefix.substring(slashIndex + 1);
+            }
+
+            // 解析host:port
+            int colonIndex = hostPort.indexOf(":");
+            if (colonIndex == -1) {
+                this.host = hostPort;
+                // 默认端口根据协议
+                if (tcUrl.startsWith("rtmp://")) {
+                    this.port = 1935;
+                } else if (tcUrl.startsWith("rtsp://")) {
+                    this.port = 554;
+                } else {
+                    this.port = 1935;
+                }
+            } else {
+                this.host = hostPort.substring(0, colonIndex);
+                this.port = Integer.parseInt(hostPort.substring(colonIndex + 1));
+            }
+
+            // app是路径的第一部分
+            if (path.length() > 0) {
+                this.app = path;
+                this.streamName = tag;
+                this.tcUrl = String.format("rtmp://%s:%d/%s", host, port, path);
+            }
+
+        } catch (Exception e) {
+            logger.error("[{}] 解析tcUrl失败: {}", tag, e.getMessage());
+        }
+    }
+
+    /**
+     * 解析RTMP URL（兼容方法）
+     */
+    private void parseRtmpUrl(String rtmpUrl) {
+        try {
+            // 移除sign参数
+            if (rtmpUrl.contains("?")) {
+                rtmpUrl = rtmpUrl.substring(0, rtmpUrl.indexOf("?"));
+            }
+
+            // 检测协议前缀
+            String prefix = "://";
+            int prefixIndex = rtmpUrl.indexOf(prefix);
+            if (prefixIndex == -1) {
+                logger.warn("[{}] URL没有有效的协议前缀: {}", tag, rtmpUrl);
+                return;
+            }
+
+            String afterPrefix = rtmpUrl.substring(prefixIndex + prefix.length());
+
+            // 分割host:port和app/stream
+            int slashIndex = afterPrefix.indexOf("/");
+            if (slashIndex == -1) {
+                slashIndex = afterPrefix.length();
+            }
+
+            String hostPort = afterPrefix.substring(0, slashIndex);
+            String appStream = afterPrefix.substring(slashIndex + 1);
+
+            // 解析host:port
+            int colonIndex = hostPort.indexOf(":");
+            if (colonIndex == -1) {
+                this.host = hostPort;
+                this.port = 1935;
+            } else {
+                this.host = hostPort.substring(0, colonIndex);
+                this.port = Integer.parseInt(hostPort.substring(colonIndex + 1));
+            }
+
+            // app和stream name
+            this.app = appStream;
+            this.streamName = tag;
+            this.tcUrl = String.format("rtmp://%s:%d/%s", host, port, appStream);
+
+            logger.info("[{}] 解析RTMP URL: host={}, port={}, tcUrl={}, stream={}, app={}",
+                    tag, host, port, tcUrl, streamName, app);
+
+        } catch (Exception e) {
+            logger.error("[{}] 解析RTMP URL失败: {}, 使用默认值", tag, e.getMessage());
+            this.host = "127.0.0.1";
+            this.port = 1935;
+            this.app = "schedule";
+            this.tcUrl = "rtmp://127.0.0.1:1935/schedule";
+            this.streamName = tag;
+        }
+    }
+
+    @Override
+    public void start(String tag) {
+        this.currentThread = Thread.currentThread();
+        this.running = true;
+
+        logger.info("[{}] ====== 启动原生RTMP推流器 ======", tag);
+        logger.info("[{}] 目标服务器: {}:{}", tag, host, port);
+        logger.info("[{}] 推流地址: {}/{}", tag, tcUrl, streamName);
+        logger.info("[{}] 完整推流URL: {}/{}?sign=xxx", tag, tcUrl, streamName);
+
+        // 启动心跳线程
+        startHeartbeat();
+
+        // 执行连接
+        doConnect();
+    }
+
+    @Override
+    public void run() {
+        start(tag);
+    }
+
+    /**
+     * 执行连接
+     */
+    private void doConnect() {
+        try {
+            // 关闭旧连接
+            closeConnection();
+
+            // 创建新连接
+            connection = new RtmpConnection(host, port, tcUrl, streamName);
+
+            if (!connection.connect()) {
+                logger.error("[{}] RTMP连接失败", tag);
+                scheduleReconnect();
+                return;
+            }
+
+            if (!connection.createStream()) {
+                logger.error("[{}] RTMP创建流失败", tag);
+                scheduleReconnect();
+                return;
+            }
+
+            if (!connection.publish()) {
+                logger.error("[{}] RTMP发布失败", tag);
+                scheduleReconnect();
+                return;
+            }
+
+            // 【关键修复】等待publish命令被ZLM处理完成
+            // jtt1078-video-server项目成功的原因：RtmpHandshakeHandler会等待服务器响应
+            // "NetStream.Publish.Start"后才进入STREAMING状态，才开始发送数据
+            // 当前项目需要等待一段时间确保ZLM完成publish处理
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+
+            // 创建ChunkWriter
+            chunkWriter = new RtmpChunkWriter(connection, tag);
+
+            // 如果有缓存的SPS/PPS，标记需要发送
+            if (cachedSPS != null && cachedPPS != null) {
+                needSendNewSequenceHeader = true;
+            }
+
+            connected = true;
+            reconnectAttempts.set(0);
+            lastHeartbeatTime = System.currentTimeMillis();
+
+            logger.info("[{}] ====== RTMP推流连接成功 ======", tag);
+
+        } catch (Exception e) {
+            logger.error("[{}] RTMP连接异常: {}", tag, e.getMessage(), e);
+            scheduleReconnect();
+        }
+    }
+
+    /**
+     * 启动心跳检测线程
+     */
+    private void startHeartbeat() {
+        if (heartbeatThread != null && heartbeatThread.isAlive()) {
+            return;
+        }
+
+        heartbeatThread = new Thread(() -> {
+            logger.info("[{}] 心跳检测线程启动", tag);
+            while (running && !Thread.currentThread().isInterrupted()) {
+                try {
+                    Thread.sleep(HEARTBEAT_INTERVAL_MS);
+
+                    if (!running) {
+                        break;
+                    }
+
+                    // 检查连接状态
+                    if (!connected || connection == null || !connection.isConnected()) {
+                        logger.warn("[{}] 心跳检测: 连接已断开，尝试重连", tag);
+                        scheduleReconnect();
+                        break;
+                    }
+
+                    // 检查最后心跳时间
+                    long now = System.currentTimeMillis();
+                    if (now - lastHeartbeatTime > HEARTBEAT_INTERVAL_MS * 3) {
+                        logger.warn("[{}] 心跳超时: {}ms未收到数据", tag, now - lastHeartbeatTime);
+                        // 连接可能还活着，只是没数据
+                    }
+
+                    lastHeartbeatTime = now;
+
+                } catch (InterruptedException e) {
+                    logger.info("[{}] 心跳线程被中断", tag);
+                    break;
+                } catch (Exception e) {
+                    logger.error("[{}] 心跳检测异常: {}", tag, e.getMessage());
+                }
+            }
+            logger.info("[{}] 心跳检测线程退出", tag);
+        }, "RTMP-Heartbeat-" + tag);
+        heartbeatThread.setDaemon(true);
+        heartbeatThread.start();
+    }
+
+    /**
+     * 安排重连
+     */
+    private void scheduleReconnect() {
+        if (!running) {
+            return;
+        }
+
+        int attempts = reconnectAttempts.incrementAndGet();
+        if (attempts > MAX_RECONNECT_ATTEMPTS) {
+            logger.error("[{}] 超过最大重连次数({})，停止重连", tag, MAX_RECONNECT_ATTEMPTS);
+            logger.info("[{}] 请检查网络和RTMP服务器状态", tag);
+            return;
+        }
+
+        // 计算退避延迟
+        long delay = Math.min(
+            INITIAL_RECONNECT_DELAY_MS * (1L << (attempts - 1)),
+            MAX_RECONNECT_DELAY_MS
+        );
+
+        // 避免过于频繁的重连
+        long now = System.currentTimeMillis();
+        if (now - lastReconnectTime < delay && attempts > 1) {
+            delay = Math.max(delay, now - lastReconnectTime);
+        }
+        lastReconnectTime = now;
+
+        logger.info("[{}] 计划{}ms后进行第{}次重连 (最多{}次)",
+                tag, delay, attempts, MAX_RECONNECT_ATTEMPTS);
+
+        // 使用当前线程执行延迟重连
+        final long finalDelay = delay;
+        new Thread(() -> {
+            try {
+                Thread.sleep(finalDelay);
+                if (running) {
+                    doConnect();
+                }
+            } catch (InterruptedException e) {
+                logger.info("[{}] 重连延迟线程被中断", tag);
+            }
+        }, "RTMP-Reconnect-" + tag).start();
+    }
+
+    /**
+     * 关闭连接
+     */
+    private void closeConnection() {
+        connected = false;
+
+        if (connection != null) {
+            try {
+                connection.close();
+            } catch (Exception e) {
+                logger.debug("[{}] 关闭连接时出错: {}", tag, e.getMessage());
+            }
+            connection = null;
+        }
+    }
+
+    @Override
+    public void sendVideoData(byte[] flvData, int timestamp) {
+        if (!connected || chunkWriter == null) {
+            logger.info("[{}] sendVideoData: not connected or chunkWriter is null, connected={}, chunkWriter={}",
+                    tag, connected, chunkWriter);
+            return;
+        }
+
+        try {
+            lastHeartbeatTime = System.currentTimeMillis();
+            logger.info("[{}] sendVideoData: flvDataLen={}, timestamp={}", tag, flvData.length, timestamp);
+            chunkWriter.sendVideoData(flvData, timestamp);
+        } catch (Exception e) {
+            logger.error("[{}] 发送视频数据失败: {}", tag, e.getMessage());
+            connected = false;
+            scheduleReconnect();
+        }
+    }
+
+    @Override
+    public void sendAVCSequenceHeader() {
+        if (!connected || chunkWriter == null) {
+            logger.warn("[{}] 未连接，无法发送AVC Sequence Header", tag);
+            return;
+        }
+
+        try {
+            // 强制重新发送SPS/PPS
+            chunkWriter.forceSendAVCSequenceHeader();
+            logger.info("[{}] 已触发发送新的AVC Sequence Header", tag);
+        } catch (Exception e) {
+            logger.error("[{}] 发送AVC Sequence Header失败: {}", tag, e.getMessage());
+        }
+    }
+
+    @Override
+    public void close() {
+        logger.info("[{}] ====== 关闭原生RTMP推流器 ======", tag);
+
+        running = false;
+        connected = false;
+
+        // 中断心跳线程
+        if (heartbeatThread != null) {
+            heartbeatThread.interrupt();
+            try {
+                heartbeatThread.join(2000);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+        }
+
+        // 关闭连接
+        closeConnection();
+
+        // 中断当前线程
+        if (currentThread != null && currentThread.isAlive()) {
+            currentThread.interrupt();
+        }
+
+        logger.info("[{}] 原生RTMP推流器已关闭", tag);
+    }
+
+    @Override
+    public boolean isConnected() {
+        return connected && connection != null && connection.isConnected();
+    }
+
+    @Override
+    public String getType() {
+        return PUBLISHER_TYPE;
+    }
+
+    @Override
+    public String getStatus() {
+        if (connected) {
+            return String.format("原生RTMP推流器, 已连接, streamId=%d, 重连次数=%d",
+                    connection != null ? connection.getStreamId() : 0,
+                    reconnectAttempts.get());
+        } else {
+            return String.format("原生RTMP推流器, 未连接, 重连次数=%d/%d",
+                    reconnectAttempts.get(), MAX_RECONNECT_ATTEMPTS);
+        }
+    }
+
+    /**
+     * 更新SPS/PPS缓存（当Channel检测到SPS变化时调用）
+     */
+    public void updateSPSPPS(byte[] sps, byte[] pps) {
+        this.cachedSPS = sps;
+        this.cachedPPS = pps;
+        this.needSendNewSequenceHeader = true;
+
+        if (chunkWriter != null) {
+            chunkWriter.updateSPSPPS(sps, pps);
+        }
+    }
+
+    /**
+     * 获取重连次数
+     */
+    public int getReconnectAttempts() {
+        return reconnectAttempts.get();
+    }
+}
+package com.genersoft.iot.vmp.jtt1078.publisher;
+
+import com.genersoft.iot.vmp.jtt1078.rtmp.NettyRtmpClient;
+import com.genersoft.iot.vmp.jtt1078.util.Configs;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Netty RTMP 推流器
+ *
+ * 使用 Netty 实现的非阻塞 RTMP 客户端
+ */
+public class NettyRtmpPublisher implements IStreamPublisher {
+
+    private static final Logger logger = LoggerFactory.getLogger(NettyRtmpPublisher.class);
+
+    private String tag;
+    private volatile boolean connected = false;
+    private static final String PUBLISHER_TYPE = "netty";
+
+    // RTMP连接配置
+    private String host;
+    private int port;
+    private String app;
+    private String tcUrl;
+    private String streamName;
+
+    // Netty RTMP 客户端
+    private NettyRtmpClient client;
+
+    public NettyRtmpPublisher(String tag) {
+        this.tag = tag;
+        loadConfig();
+    }
+
+    /**
+     * 从配置加载RTMP连接参数
+     */
+    private void loadConfig() {
+        // 优先使用原生RTMP配置
+        String configHost = Configs.get("rtmp.native.host");
+        String configPort = Configs.get("rtmp.native.port");
+        String configApp = Configs.get("rtmp.native.app");
+        String configTcUrl = Configs.get("rtmp.native.tcUrl");
+
+        // 如果有完整的tcUrl配置，直接使用
+        if (configTcUrl != null && !configTcUrl.isEmpty()) {
+            this.tcUrl = configTcUrl.replace("{TAG}", tag);
+            // 从tcUrl解析host和port
+            parseTcUrl(configTcUrl);
+            logger.info("[{}] 使用配置的tcUrl: {}", tag, this.tcUrl);
+            return;
+        }
+
+        // 如果有分离配置，使用分离配置
+        if (configHost != null && !configHost.isEmpty()) {
+            this.host = configHost;
+        } else {
+            this.host = "127.0.0.1";
+        }
+
+        if (configPort != null && !configPort.isEmpty()) {
+            this.port = Integer.parseInt(configPort);
+        } else {
+            this.port = 1935;
+        }
+
+        if (configApp != null && !configApp.isEmpty()) {
+            this.app = configApp;
+        } else {
+            this.app = "schedule";
+        }
+
+        // streamName = tag
+        this.streamName = tag;
+
+        // 从rtmp.url获取sign参数
+        String sign = "41db35390ddad33f83944f44b8b75ded";
+        String rtmpUrl = Configs.get("rtmp.url");
+        if (rtmpUrl != null && rtmpUrl.contains("sign=")) {
+            int signStart = rtmpUrl.indexOf("sign=") + 5;
+            int signEnd = rtmpUrl.indexOf("&", signStart);
+            if (signEnd == -1) signEnd = rtmpUrl.length();
+            String extractedSign = rtmpUrl.substring(signStart, signEnd);
+            if (!extractedSign.isEmpty() && !"{sign}".equals(extractedSign)) {
+                sign = extractedSign;
+            }
+        }
+
+        // 完整URL: rtmp://host:port/app/streamName?sign=xxx
+        this.tcUrl = String.format("rtmp://%s:%d/%s/%s?sign=%s", host, port, app, tag, sign);
+
+        logger.info("[{}] Netty RTMP推流器配置: host={}, port={}, app={}, stream={}, tcUrl={}",
+                tag, host, port, app, streamName, tcUrl);
+    }
+
+    /**
+     * 从tcUrl解析host和port
+     */
+    private void parseTcUrl(String tcUrl) {
+        try {
+            // 移除sign参数
+            if (tcUrl.contains("?")) {
+                tcUrl = tcUrl.substring(0, tcUrl.indexOf("?"));
+            }
+
+            // 支持 rtmp://, rtsp://, http:// 等协议
+            String prefix = "://";
+            int prefixIndex = tcUrl.indexOf(prefix);
+            if (prefixIndex == -1) {
+                logger.warn("[{}] tcUrl没有有效的协议前缀: {}", tag, tcUrl);
+                return;
+            }
+
+            String afterPrefix = tcUrl.substring(prefixIndex + prefix.length());
+
+            // 分割host:port和path
+            int slashIndex = afterPrefix.indexOf("/");
+            String hostPort;
+            String path;
+            if (slashIndex == -1) {
+                hostPort = afterPrefix;
+                path = "";
+            } else {
+                hostPort = afterPrefix.substring(0, slashIndex);
+                path = afterPrefix.substring(slashIndex + 1);
+            }
+
+            // 解析host:port
+            int colonIndex = hostPort.indexOf(":");
+            if (colonIndex == -1) {
+                this.host = hostPort;
+                this.port = 1935;
+            } else {
+                this.host = hostPort.substring(0, colonIndex);
+                this.port = Integer.parseInt(hostPort.substring(colonIndex + 1));
+            }
+
+            // app是路径的第一部分
+            if (path.length() > 0) {
+                this.app = path;
+                this.streamName = tag;
+                this.tcUrl = String.format("rtmp://%s:%d/%s", host, port, path);
+            }
+
+        } catch (Exception e) {
+            logger.error("[{}] 解析tcUrl失败: {}", tag, e.getMessage());
+        }
+    }
+
+    @Override
+    public void start(String tag) {
+        this.tag = tag;
+
+        logger.info("[{}] ====== 启动Netty RTMP推流器 ======", tag);
+        logger.info("[{}] 目标服务器: {}:{}", tag, host, port);
+        logger.info("[{}] 推流地址: {}/{}", tag, tcUrl, streamName);
+
+        try {
+            // 创建 Netty RTMP 客户端
+            client = new NettyRtmpClient(tcUrl, app, streamName);
+            client.start();
+
+            connected = true;
+            logger.info("[{}] ====== Netty RTMP推流器启动成功 ======", tag);
+
+        } catch (Exception e) {
+            logger.error("[{}] Netty RTMP推流器启动异常: {}", tag, e.getMessage(), e);
+            connected = false;
+        }
+    }
+
+    @Override
+    public void sendVideoData(byte[] flvData, int timestamp) {
+        if (!connected || client == null) {
+            logger.debug("[{}] sendVideoData: not connected", tag);
+            return;
+        }
+
+        try {
+            // 将 byte[] 转换为 Netty ByteBuf
+            ByteBuf buf = Unpooled.wrappedBuffer(flvData);
+            client.send(buf);
+
+            logger.debug("[{}] sendVideoData: flvDataLen={}, timestamp={}", tag, flvData.length, timestamp);
+        } catch (Exception e) {
+            logger.error("[{}] 发送视频数据失败: {}", tag, e.getMessage());
+            connected = false;
+        }
+    }
+
+    @Override
+    public void sendAVCSequenceHeader() {
+        // Netty 版本不需要单独发送 Sequence Header
+        // 因为 FLV Tag 已经包含了 Sequence Header 信息
+        logger.debug("[{}] sendAVCSequenceHeader: 无需操作（由FLV Tag携带）", tag);
+    }
+
+    @Override
+    public void close() {
+        logger.info("[{}] ====== 关闭Netty RTMP推流器 ======", tag);
+
+        connected = false;
+
+        if (client != null) {
+            try {
+                client.close();
+            } catch (Exception e) {
+                logger.debug("[{}] 关闭客户端时出错: {}", tag, e.getMessage());
+            }
+            client = null;
+        }
+
+        logger.info("[{}] Netty RTMP推流器已关闭", tag);
+    }
+
+    @Override
+    public boolean isConnected() {
+        return connected && client != null;
+    }
+
+    @Override
+    public String getType() {
+        return PUBLISHER_TYPE;
+    }
+
+    @Override
+    public String getStatus() {
+        if (connected) {
+            return String.format("Netty RTMP推流器, 已连接, streamName=%s", streamName);
+        } else {
+            return "Netty RTMP推流器, 未连接";
+        }
+    }
+}
 \ No newline at end of file
@@ -48,7 +48,11 @@ public final class PublishManager
     public void publishVideo(String tag, int sequence, long timestamp, int payloadType, byte[] data)
     {
         Channel chl = channels.get(tag);
-        if (chl != null) chl.writeVideo(sequence, timestamp, payloadType, data);
+        if (chl == null) {
+            logger.warn("[{}] publishVideo: Channel不存在, 跳过视频数据, channels.size={}", tag, channels.size());
+            return;
+        }
+        chl.writeVideo(sequence, timestamp, payloadType, data);
     }
     public Channel open(String tag)
+package com.genersoft.iot.vmp.jtt1078.publisher;
+
+import com.genersoft.iot.vmp.jtt1078.util.Configs;
+
+/**
+ * 推流器工厂类
+ *
+ * 根据配置决定创建FFmpeg推流器还是原生RTMP推流器
+ *
+ * 配置项：
+ * - publisher.type: ffmpeg | native | netty (默认ffmpeg)
+ * - publisher.native.enabled: true | false (备用配置项)
+ */
+public class StreamPublisherFactory {
+
+    /** 推流器类型常量 */
+    public static final String TYPE_FFMPEG = "ffmpeg";
+    public static final String TYPE_NATIVE = "native";
+    public static final String TYPE_NETTY = "netty";
+
+    /** 默认推流器类型 */
+    private static final String DEFAULT_TYPE = TYPE_FFMPEG;
+
+    /**
+     * 创建推流器实例
+     *
+     * @param tag 通道标识
+     * @return IStreamPublisher实现实例
+     */
+    public static IStreamPublisher create(String tag) {
+        String type = getPublisherType();
+
+        if (TYPE_NETTY.equalsIgnoreCase(type)) {
+            try {
+                return new NettyRtmpPublisher(tag);
+            } catch (Exception e) {
+                System.err.println("[" + tag + "] 创建Netty RTMP推流器失败，回退到FFmpeg: " + e.getMessage());
+                return createFFmpegPublisher(tag);
+            }
+        } else if (TYPE_NATIVE.equalsIgnoreCase(type)) {
+            try {
+                return new NativeRtmpPublisher(tag);
+            } catch (Exception e) {
+                // 如果原生RTMP创建失败，回退到FFmpeg
+                System.err.println("[" + tag + "] 创建原生RTMP推流器失败，回退到FFmpeg: " + e.getMessage());
+                return createFFmpegPublisher(tag);
+            }
+        } else {
+            return createFFmpegPublisher(tag);
+        }
+    }
+
+    /**
+     * 创建FFmpeg推流器
+     */
+    private static IStreamPublisher createFFmpegPublisher(String tag) {
+        return new FFmpegPublisher(tag);
+    }
+
+    /**
+     * 获取配置的推流器类型
+     */
+    private static String getPublisherType() {
+        // 优先使用publisher.type配置
+        String type = Configs.get("publisher.type");
+        if (type != null && !type.trim().isEmpty()) {
+            return type.trim().toLowerCase();
+        }
+
+        // 备用配置项检查
+        String nativeEnabled = Configs.get("publisher.native.enabled");
+        if ("true".equalsIgnoreCase(nativeEnabled)) {
+            return TYPE_NATIVE;
+        }
+
+        return DEFAULT_TYPE;
+    }
+
+    /**
+     * 检查是否使用原生RTMP推流器
+     */
+    public static boolean isNativeRtmpEnabled() {
+        return TYPE_NATIVE.equalsIgnoreCase(getPublisherType()) || TYPE_NETTY.equalsIgnoreCase(getPublisherType());
+    }
+
+    /**
+     * 获取推流器类型描述
+     */
+    public static String getPublisherTypeDescription() {
+        String type = getPublisherType();
+        switch (type) {
+            case TYPE_NETTY:
+                return "Netty RTMP推流器（非阻塞）";
+            case TYPE_NATIVE:
+                return "原生RTMP推流器（无缝码流切换）";
+            case TYPE_FFMPEG:
+            default:
+                return "FFmpeg推流器（码流切换需重启）";
+        }
+    }
+}
+package com.genersoft.iot.vmp.jtt1078.rtmp;
+
+import io.netty.buffer.ByteBuf;
+import java.util.Map;
+
+/**
+ * AMF0 编码工具类
+ */
+public class Amf0Util {
+
+    // AMF0 Markers
+    public static final byte NUMBER = 0x00;
+    public static final byte BOOLEAN = 0x01;
+    public static final byte STRING = 0x02;
+    public static final byte OBJECT = 0x03;
+    public static final byte NULL = 0x05;
+    public static final byte ECMA_ARRAY = 0x08;
+    public static final byte OBJECT_END = 0x09;
+
+    public static void writeString(ByteBuf out, String str) {
+        out.writeByte(STRING);
+        writeStringBare(out, str);
+    }
+
+    // 不带 Marker 的字符串（用于 Object 的 Key）
+    public static void writeStringBare(ByteBuf out, String str) {
+        if (str == null) str = "";
+        byte[] bytes = str.getBytes();
+        out.writeShort(bytes.length);
+        out.writeBytes(bytes);
+    }
+
+    public static void writeNumber(ByteBuf out, double num) {
+        out.writeByte(NUMBER);
+        out.writeLong(Double.doubleToLongBits(num));
+    }
+
+    public static void writeBoolean(ByteBuf out, boolean val) {
+        out.writeByte(BOOLEAN);
+        out.writeByte(val ? 1 : 0);
+    }
+
+    public static void writeNull(ByteBuf out) {
+        out.writeByte(NULL);
+    }
+
+    public static void writeObject(ByteBuf out, Map<String, Object> props) {
+        out.writeByte(OBJECT);
+        if (props != null) {
+            for (Map.Entry<String, Object> entry : props.entrySet()) {
+                writeStringBare(out, entry.getKey());
+                Object val = entry.getValue();
+                if (val instanceof String) writeString(out, (String) val);
+                else if (val instanceof Number) writeNumber(out, ((Number) val).doubleValue());
+                else if (val instanceof Boolean) writeBoolean(out, (Boolean) val);
+                else writeNull(out);
+            }
+        }
+        // Object End Marker (00 00 09)
+        out.writeMedium(0x000009);
+    }
+}
 \ No newline at end of file
+package com.genersoft.iot.vmp.jtt1078.rtmp;
+
+import io.netty.bootstrap.Bootstrap;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.*;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+/**
+ * Netty RTMP 客户端
+ */
+public class NettyRtmpClient {
+    private static final Logger logger = LoggerFactory.getLogger(NettyRtmpClient.class);
+
+    // 共享线程池
+    private static final EventLoopGroup sharedGroup = new NioEventLoopGroup(Runtime.getRuntime().availableProcessors() * 2);
+
+    private Channel channel;
+    private final String rtmpUrl;
+    private final String app;
+    private final String stream;
+
+    // 增加一个状态标记，只有握手完成才能发送数据
+    private volatile boolean isReady = false;
+
+    public NettyRtmpClient(String rtmpUrl, String app, String stream) {
+        this.rtmpUrl = rtmpUrl;
+        this.app = app;
+        this.stream = stream;
+    }
+
+    public void start() {
+        // 1. 解析 RTMP URL 获取 IP 和 端口
+        URI uri;
+        try {
+            // Java URI 解析 rtmp:// 有时会报错，简单处理去掉 scheme
+            String tempUrl = rtmpUrl.replace("rtmp://", "http://");
+            uri = new URI(tempUrl);
+        } catch (URISyntaxException e) {
+            logger.error("[{}] RTMP URL 格式错误: {}", stream, rtmpUrl);
+            return;
+        }
+
+        String host = uri.getHost();
+        int port = uri.getPort();
+        if (port == -1) port = 1935; // 默认 RTMP 端口
+
+        Bootstrap b = new Bootstrap();
+        b.group(sharedGroup)
+                .channel(NioSocketChannel.class)
+                .option(ChannelOption.TCP_NODELAY, true) // 禁用 Nagle 算法，降低延迟
+                .handler(new ChannelInitializer<SocketChannel>() {
+                    @Override
+                    protected void initChannel(SocketChannel ch) {
+                        // 传入回调，当 Handler 状态变为 STREAMING 时通知 Client
+                        RtmpHandshakeHandler handler = new RtmpHandshakeHandler(app, rtmpUrl, stream);
+                        handler.setOnReadyListener(() -> isReady = true);
+                        ch.pipeline().addLast(handler);
+                    }
+                });
+
+        logger.info("[{}] 正在连接 RTMP 服务器: {}:{}", stream, host, port);
+        b.connect(host, port).addListener((ChannelFutureListener) future -> {
+            if (future.isSuccess()) {
+                this.channel = future.channel();
+                logger.info("[{}] RTMP TCP 连接成功: {}", stream, rtmpUrl);
+            } else {
+                logger.error("[{}] RTMP 连接失败: {}", stream, rtmpUrl, future.cause());
+            }
+        });
+    }
+
+    public void send(ByteBuf flvTag) {
+        // 【关键修复】
+        // 1. 必须 channel active
+        // 2. 必须 isReady (RTMP 握手已完成)
+        // 否则直接丢弃包并释放内存，绝对不能发给服务器！
+        if (channel != null && channel.isActive() && isReady) {
+            channel.writeAndFlush(flvTag);
+        } else {
+            // 如果还没握手完成就发包，服务器会报错非法 BodySize
+            // 必须释放 flvTag，否则内存泄漏
+            if (flvTag.refCnt() > 0) {
+                flvTag.release();
+            }
+        }
+    }
+
+    public void close() {
+        if (channel != null) {
+            channel.close();
+        }
+    }
+}
 \ No newline at end of file
+package com.genersoft.iot.vmp.jtt1078.rtmp;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+
+/**
+ * FLV数据到RTMP消息的转换器
+ *
+ * 功能：
+ * 1. 解析FLV Video Tag，提取H.264 NAL单元
+ * 2. 将FLV时间戳转换为RTMP时间戳
+ * 3. 处理SPS/PPS序列头
+ * 4. 处理I帧和P帧
+ *
+ * FLV Video Tag格式：
+ * [PreviousTagSize(4)][Tag Type(1)][DataSize(3)][Timestamp(3)][TimestampExt(1)][StreamID(3)][VideoData]
+ *
+ * VideoData格式（H.264）：
+ * [FrameType(1)][AVCPacketType(1)][CompositionTime(3)][NALUs]
+ *
+ * - FrameType: 0x17=I帧, 0x27=P/B帧
+ * - AVCPacketType: 0x00=AVC Sequence Header, 0x01=NALU
+ * - CompositionTime: pts - dts偏移
+ */
+public class RtmpChunkWriter {
+
+    static Logger logger = LoggerFactory.getLogger(RtmpChunkWriter.class);
+
+    private RtmpConnection connection;
+    private String tag;
+
+    // 时间戳
+    private int lastVideoTimestamp = 0;
+    private int lastAudioTimestamp = 0;
+
+    // 关键标记
+    private boolean hasSentAVCSequenceHeader = false;
+    private byte[] lastSPS = null;
+    private byte[] lastPPS = null;
+
+    // FLV Tag类型常量
+    private static final byte FLV_TAG_TYPE_VIDEO = 9;
+    private static final byte FLV_TAG_TYPE_AUDIO = 8;
+
+    // AVC NAL单元类型
+    private static final int NAL_UNIT_TYPE_SPS = 7;
+    private static final int NAL_UNIT_TYPE_PPS = 8;
+    private static final int NAL_UNIT_TYPE_IDR = 5;
+    private static final int NAL_UNIT_TYPE_NON_IDR = 1;
+
+    public RtmpChunkWriter(RtmpConnection connection, String tag) {
+        this.connection = connection;
+        this.tag = tag;
+    }
+
+    /**
+     * 发送FLV视频数据
+     *
+     * @param flvData 完整的FLV Video Tag数据
+     * @param timestamp FLV中的时间戳
+     */
+    public void sendVideoData(byte[] flvData, int timestamp) throws IOException {
+        if (flvData == null || flvData.length < 16) {
+            return;
+        }
+
+        // 跳过PreviousTagSize (4字节)
+        int offset = 4;
+
+        // 检查Tag Type
+        if (flvData[offset] != FLV_TAG_TYPE_VIDEO) {
+            return;
+        }
+        offset++;
+
+        // 读取DataSize (3字节, big-endian)
+        int dataSize = ((flvData[offset] & 0xFF) << 16) |
+                       ((flvData[offset + 1] & 0xFF) << 8) |
+                       (flvData[offset + 2] & 0xFF);
+        offset += 3;
+
+        // 跳过Timestamp (3字节) + TimestampExt (1字节)
+        offset += 4;
+
+        // 跳过StreamID (3字节)
+        offset += 3;
+
+        // 现在offset指向VideoData
+        if (offset >= flvData.length) {
+            return;
+        }
+
+        byte videoInfo = flvData[offset];  // FrameType + CodecID
+        offset++;
+
+        byte avcPacketType = flvData[offset];  // AVCPacketType
+        offset++;
+
+        // 读取CompositionTime (3字节)
+        int compositionTime = ((flvData[offset] & 0xFF) << 16) |
+                             ((flvData[offset + 1] & 0xFF) << 8) |
+                             (flvData[offset + 2] & 0xFF);
+        offset += 3;
+
+        // 计算RTMP时间戳
+        // FLV timestamp单位是毫秒，RTMP也是毫秒
+        int rtmpTimestamp = timestamp & 0xFFFFFF;  // 24位时间戳
+        lastVideoTimestamp = rtmpTimestamp;
+
+        if (avcPacketType == 0x00) {
+            // AVC Sequence Header (SPS/PPS)
+            logger.info("[{}] 收到AVC Sequence Header (SPS/PPS), offset={}, remaining={}", tag, offset, flvData.length - offset);
+            handleAVCSequenceHeader(flvData, offset);
+        } else if (avcPacketType == 0x01) {
+            // NALU
+            logger.info("[{}] 收到NALU数据, timestamp={}, offset={}, remaining={}", tag, rtmpTimestamp, offset, flvData.length - offset);
+            handleNALU(flvData, offset, rtmpTimestamp);
+        } else {
+            logger.warn("[{}] 未知AVCPacketType: 0x{}, 数据长度={}", tag, String.format("%02X", avcPacketType), flvData.length);
+        }
+    }
+
+    /**
+     * 处理AVC Sequence Header
+     *
+     * FLV中封装的AVCDecoderConfigurationRecord：
+     * [configurationVersion(1)][AVCProfileIndication(1)][profile_compatibility(1)][AVCLevelIndication(1)]
+     * [lengthSizeMinusOne(1)][numOfSequenceParameterSets(1)][SPS length(2)][SPS data][numOfPictureParameterSets(1)][PPS length(2)][PPS data]
+     */
+    private void handleAVCSequenceHeader(byte[] data, int offset) {
+        try {
+            // 解析AVCDecoderConfigurationRecord
+            int pos = offset;
+
+            byte configurationVersion = data[pos++];
+            byte AVCProfileIndication = data[pos++];
+            byte profileCompatibility = data[pos++];
+            byte AVCLevelIndication = data[pos++];
+
+            byte lengthSizeMinusOne = data[pos++];  // 通常是3，表示NALU长度占4字节
+
+            // SPS
+            byte numOfSequenceParameterSets = data[pos++];
+            int spsLength = ((data[pos] & 0xFF) << 8) | (data[pos + 1] & 0xFF);
+            pos += 2;
+            lastSPS = new byte[spsLength];
+            System.arraycopy(data, pos, lastSPS, 0, spsLength);
+            pos += spsLength;
+
+            // PPS
+            byte numOfPictureParameterSets = data[pos++];
+            int ppsLength = ((data[pos] & 0xFF) << 8) | (data[pos + 1] & 0xFF);
+            pos += 2;
+            lastPPS = new byte[ppsLength];
+            System.arraycopy(data, pos, lastPPS, 0, ppsLength);
+
+            hasSentAVCSequenceHeader = false;  // 重置，强制发送新的
+
+            // 调试日志：打印SPS/PPS的十六进制
+            StringBuilder spsHex = new StringBuilder();
+            for (int i = 0; i < Math.min(lastSPS.length, 20); i++) {
+                spsHex.append(String.format("%02X ", lastSPS[i] & 0xFF));
+            }
+            StringBuilder ppsHex = new StringBuilder();
+            for (int i = 0; i < Math.min(lastPPS.length, 10); i++) {
+                ppsHex.append(String.format("%02X ", lastPPS[i] & 0xFF));
+            }
+            logger.info("[{}] 解析到AVC Sequence Header: SPS长度={}, PPS长度={}, SPS前20字节=[{}], PPS前10字节=[{}], profile={}, level={}",
+                    tag, spsLength, ppsLength, spsHex.toString(), ppsHex.toString(),
+                    String.format("0x%02X", AVCProfileIndication), String.format("0x%02X", AVCLevelIndication));
+
+        } catch (Exception e) {
+            logger.error("[{}] 解析AVC Sequence Header失败: {}", tag, e.getMessage());
+        }
+    }
+
+    /**
+     * 处理NALU数据
+     */
+    private void handleNALU(byte[] data, int offset, int timestamp) throws IOException {
+        if (lastSPS == null || lastPPS == null) {
+            logger.warn("[{}] 还未收到SPS/PPS，跳过NALU. lastSPS={}, lastPPS={}", tag,
+                    lastSPS != null ? "set(" + lastSPS.length + ")" : "null",
+                    lastPPS != null ? "set(" + lastPPS.length + ")" : "null");
+            return;
+        }
+
+        // 发送AVC Sequence Header（如果还没发送）
+        if (!hasSentAVCSequenceHeader) {
+            sendAVCSequenceHeaderPacket();
+            hasSentAVCSequenceHeader = true;
+        }
+
+        // 解析NALU
+        // FLV中NALU格式: [NALU长度(4字节)][NALU数据...]
+        int pos = offset;
+        int nalType = -1;
+
+        while (pos + 4 < data.length) {
+            // 读取NALU长度
+            int nalLength = ((data[pos] & 0xFF) << 24) |
+                           ((data[pos + 1] & 0xFF) << 16) |
+                           ((data[pos + 2] & 0xFF) << 8) |
+                           (data[pos + 3] & 0xFF);
+            pos += 4;
+
+            if (pos + nalLength > data.length) {
+                break;
+            }
+
+            nalType = data[pos] & 0x1F;
+
+            // 构建RTMP视频数据
+            // 格式: [FrameType(1)][AVCPacketType(1)][CompositionTime(3)][NALU]
+            byte[] rtmpData = new byte[5 + nalLength];
+            rtmpData[0] = (byte) (nalType == NAL_UNIT_TYPE_IDR ? 0x17 : 0x27);  // I帧或P帧
+            rtmpData[1] = 0x01;  // AVCPacketType = NALU
+            rtmpData[2] = 0x00;  // CompositionTime
+            rtmpData[3] = 0x00;
+            rtmpData[4] = 0x00;
+
+            // 复制NALU数据
+            System.arraycopy(data, pos, rtmpData, 5, nalLength);
+
+            // 打印NALU的十六进制便于调试
+            StringBuilder hex = new StringBuilder();
+            for (int i = 0; i < Math.min(nalLength, 20); i++) {
+                hex.append(String.format("%02X ", rtmpData[5 + i] & 0xFF));
+            }
+            if (nalLength > 20) {
+                hex.append("...(").append(nalLength).append(" bytes total)");
+            }
+            logger.info("[{}] 发送NALU到RTMP: nalType=0x{}, timestamp={}, nalLength={}, firstBytes={}", tag,
+                    Integer.toHexString(nalType), timestamp, nalLength, hex.toString());
+
+            // 发送到RTMP
+            connection.sendVideoData(rtmpData, timestamp);
+
+            pos += nalLength;
+        }
+    }
+
+    /**
+     * 发送AVC Sequence Header到RTMP
+     * 这是实现无缝码流切换的关键！
+     *
+     * 注意：lastSPS和lastPPS是从FLV数据中提取的，不包含start code
+     * FLV中的SPS格式: [profile_idc(1)][constraint(1)][level_idc(1)][...]
+     * 实际H.264 SPS (Annex B): [00 00 00 01][67][profile_idc][constraint][level_idc][...]
+     */
+    private void sendAVCSequenceHeaderPacket() throws IOException {
+        if (lastSPS == null || lastPPS == null) {
+            logger.warn("[{}] SPS/PPS为空，无法发送Sequence Header", tag);
+            return;
+        }
+
+        // 构建AVCDecoderConfigurationRecord
+        // 这个格式和FLV中的略有不同，需要转换
+        int recordLength = 11 + lastSPS.length + lastPPS.length;
+        byte[] configRecord = new byte[recordLength];
+
+        int pos = 0;
+        configRecord[pos++] = 0x01;  // configurationVersion
+        // SPS是从FLV提取的，没有start code
+        // FLV SPS: [profile_idc(1)][constraint(1)][level_idc(1)][...]
+        // 所以 profile_idc 在 lastSPS[0], constraint 在 lastSPS[1], level 在 lastSPS[2]
+        configRecord[pos++] = lastSPS.length > 0 ? lastSPS[0] : 0x64;  // AVCProfileIndication
+        configRecord[pos++] = lastSPS.length > 1 ? lastSPS[1] : 0x00;  // profile_compatibility
+        configRecord[pos++] = lastSPS.length > 2 ? lastSPS[2] : 0x1F;  // AVCLevelIndication
+        configRecord[pos++] = (byte) 0xFF;  // lengthSizeMinusOne = 3 (NAL长度占4字节)
+
+        // SPS
+        configRecord[pos++] = (byte) 0xE1;  // numOfSequenceParameterSets = 1
+        configRecord[pos++] = (byte) ((lastSPS.length >> 8) & 0xFF);  // SPS length high
+        configRecord[pos++] = (byte) (lastSPS.length & 0xFF);  // SPS length low
+        System.arraycopy(lastSPS, 0, configRecord, pos, lastSPS.length);
+        pos += lastSPS.length;
+
+        // PPS (同样没有start code)
+        configRecord[pos++] = 0x01;  // numOfPictureParameterSets = 1
+        configRecord[pos++] = (byte) ((lastPPS.length >> 8) & 0xFF);  // PPS length high
+        configRecord[pos++] = (byte) (lastPPS.length & 0xFF);  // PPS length low
+        System.arraycopy(lastPPS, 0, configRecord, pos, lastPPS.length);
+
+        // 构建RTMP视频数据
+        // [FrameType(1)][AVCPacketType(1)][CompositionTime(3)][ConfigRecord]
+        byte[] rtmpData = new byte[5 + recordLength];
+        rtmpData[0] = 0x17;  // AVC sequence header (I-frame)
+        rtmpData[1] = 0x00;  // AVCPacketType = AVC sequence header
+        rtmpData[2] = 0x00;
+        rtmpData[3] = 0x00;
+        rtmpData[4] = 0x00;
+        System.arraycopy(configRecord, 0, rtmpData, 5, recordLength);
+
+        // 打印Sequence Header的十六进制便于调试
+        StringBuilder hex = new StringBuilder();
+        for (int i = 0; i < Math.min(rtmpData.length, 64); i++) {
+            hex.append(String.format("%02X ", rtmpData[i] & 0xFF));
+        }
+        if (rtmpData.length > 64) {
+            hex.append("...(").append(rtmpData.length).append(" bytes total)");
+        }
+        logger.info("[{}] 发送AVC Sequence Header到RTMP, 数据长度={}, hex={}", tag, rtmpData.length, hex.toString());
+        logger.info("[{}] SPS profile/level: configRecord[1]={}, configRecord[3]={}",
+                tag, String.format("0x%02X", configRecord[1]), String.format("0x%02X", configRecord[3]));
+
+        // 发送到RTMP
+        connection.sendVideoData(rtmpData, 0);
+    }
+
+    /**
+     * 强制发送新的AVC Sequence Header
+     * 用于码流切换时立即发送新的SPS/PPS
+     */
+    public void forceSendAVCSequenceHeader() {
+        hasSentAVCSequenceHeader = false;
+    }
+
+    /**
+     * 更新SPS/PPS（当检测到码流变化时调用）
+     */
+    public void updateSPSPPS(byte[] sps, byte[] pps) {
+        this.lastSPS = sps;
+        this.lastPPS = pps;
+        this.hasSentAVCSequenceHeader = false;  // 重置，强制发送新的
+        logger.info("[{}] 更新SPS/PPS: SPS长度={}, PPS长度={}", tag,
+                sps != null ? sps.length : 0, pps != null ? pps.length : 0);
+    }
+
+    /**
+     * 发送FLV音频数据
+     */
+    public void sendAudioData(byte[] flvData, int timestamp) throws IOException {
+        if (flvData == null || flvData.length < 16) {
+            return;
+        }
+
+        // 跳过PreviousTagSize (4字节)
+        int offset = 4;
+
+        // 检查Tag Type
+        if (flvData[offset] != FLV_TAG_TYPE_AUDIO) {
+            return;
+        }
+        offset++;
+
+        // 读取DataSize (3字节)
+        int dataSize = ((flvData[offset] & 0xFF) << 16) |
+                       ((flvData[offset + 1] & 0xFF) << 8) |
+                       (flvData[offset + 2] & 0xFF);
+        offset += 3;
+
+        // 跳过Timestamp (3字节) + TimestampExt (1字节)
+        offset += 4;
+
+        // 跳过StreamID (3字节)
+        offset += 3;
+
+        // 提取音频数据
+        int audioDataSize = dataSize - 1;  // 减去audioInfo的1字节
+        if (offset + audioDataSize > flvData.length) {
+            return;
+        }
+
+        byte[] audioData = new byte[audioDataSize];
+        System.arraycopy(flvData, offset + 1, audioData, 0, audioDataSize);  // +1 跳过audioInfo
+
+        lastAudioTimestamp = timestamp & 0xFFFFFF;
+        connection.sendAudioData(audioData, lastAudioTimestamp);
+    }
+
+    public boolean hasSentAVCSequenceHeader() {
+        return hasSentAVCSequenceHeader;
+    }
+}
+package com.genersoft.iot.vmp.jtt1078.rtmp;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.nio.ByteBuffer;
+
+/**
+ * RTMP连接管理
+ *
+ * 负责RTMP握手、连接、创建流等基础操作
+ *
+ * RTMP协议版本：1.0 (Flash Media Server兼容)
+ *
+ * 握手流程：
+ * C0+C1 → S0+S1+S2 → C2 → 连接建立
+ *
+ * 连接流程：
+ * connect(tcUrl) → createStream() → publish(streamName)
+ */
+public class RtmpConnection {
+
+    static Logger logger = LoggerFactory.getLogger(RtmpConnection.class);
+
+    private String host;
+    private int port;
+    private String tcUrl;
+    private String streamName;
+
+    private Socket socket;
+    private InputStream inputStream;
+    private OutputStream outputStream;
+
+    private volatile boolean connected = false;
+    private int streamId = 0;  // RTMP流ID
+
+    // RTMP Chunk大小，默认128字节
+    public static final int CHUNK_SIZE = 4096;  // 参考项目使用4096
+
+    // 协议版本
+    private static final byte RTMP_VERSION = 3;
+
+    // RTMP消息类型
+    public static final byte MSG_SET_CHUNK_SIZE = 1;
+    public static final byte MSG_ABORT = 2;
+    public static final byte MSG_ACKNOWLEDGEMENT = 3;
+    public static final byte MSG_USER_CONTROL_MESSAGE = 4;
+    public static final byte MSG_WINDOW_ACK_SIZE = 5;
+    public static final byte MSG_SET_PEER_BANDWIDTH = 6;
+    public static final byte MSG_AUDIO_MESSAGE = 8;
+    public static final byte MSG_VIDEO_MESSAGE = 9;
+    public static final byte MSG_DATA_MESSAGE = 18;  // AMF0 Data
+    public static final byte MSG_SHARED_OBJECT_MESSAGE = 19;
+    public static final byte MSG_COMMAND_MESSAGE = 20;  // AMF0 Command
+    public static final byte MSG_COMMAND_MESSAGE_AMF3 = 17;  // AMF3 Command
+    public static final byte MSG_WINDOW_ACK_SIZE_2 = 5;
+
+    // Chunk Stream ID
+    // 标准RTMP使用chunk stream ID 3进行命令交互
+    public static final byte CHUNK_STREAM_CONTROL = 2;
+    public static final byte CHUNK_STREAM_COMMAND = 3;
+    public static final byte CHUNK_STREAM_VIDEO = 6;
+    public static final byte CHUNK_STREAM_AUDIO = 4;  // 参考项目使用4
+
+    public RtmpConnection(String host, int port, String tcUrl, String streamName) {
+        this.host = host;
+        this.port = port;
+        this.tcUrl = tcUrl;
+        this.streamName = streamName;
+    }
+
+    /**
+     * 连接到RTMP服务器
+     * @return true表示连接成功
+     */
+    public boolean connect() {
+        try {
+            logger.info("[{}] 正在连接到RTMP服务器: {}:{}", streamName, host, port);
+
+            socket = new Socket();
+            socket.setKeepAlive(true);
+            socket.setSoTimeout(10000);  // 10秒超时
+            socket.connect(new InetSocketAddress(host, port), 10000);
+
+            inputStream = socket.getInputStream();
+            outputStream = socket.getOutputStream();
+
+            // 执行握手
+            if (!doHandshake()) {
+                logger.error("[{}] RTMP握手失败", streamName);
+                return false;
+            }
+
+            logger.info("[{}] RTMP握手成功", streamName);
+
+            // 【关键修复】发送SetChunkSize命令，设置chunk大小为4096
+            if (!sendSetChunkSize()) {
+                logger.error("[{}] SetChunkSize命令失败", streamName);
+                return false;
+            }
+
+            // 发送连接命令
+            if (!sendConnect()) {
+                logger.error("[{}] RTMP连接命令失败", streamName);
+                return false;
+            }
+
+            connected = true;
+            logger.info("[{}] RTMP连接成功", streamName);
+            return true;
+
+        } catch (Exception e) {
+            logger.error("[{}] RTMP连接失败: {}", streamName, e.getMessage(), e);
+            return false;
+        }
+    }
+
+    /**
+     * RTMP握手
+     *
+     * 客户端发送 C0 + C1
+     * 服务器响应 S0 + S1 + S2
+     * 客户端发送 C2
+     */
+    private boolean doHandshake() throws IOException {
+        // C0 + C1
+        byte[] c0c1 = new byte[1 + 1536];  // C0(1字节) + C1(1536字节)
+        c0c1[0] = RTMP_VERSION;  // C0: 版本号，通常是3
+
+        // C1: 时间戳(4字节) + 零(4字节) + 随机数据(1528字节)
+        long timestamp = System.currentTimeMillis() / 1000;
+        c0c1[1] = (byte) (timestamp >> 24);
+        c0c1[2] = (byte) (timestamp >> 16);
+        c0c1[3] = (byte) (timestamp >> 8);
+        c0c1[4] = (byte) timestamp;
+        // 字节5-8是零
+        // 字节9-1536是随机数据
+        for (int i = 9; i < 1537; i++) {
+            c0c1[i] = (byte) (Math.random() * 256);
+        }
+
+        logger.debug("[{}] 发送C0+C1...", streamName);
+        outputStream.write(c0c1);
+        outputStream.flush();
+
+        // 读取S0 + S1 + S2
+        byte[] s0s1s2 = new byte[1 + 1536 + 1536];
+        int totalRead = 0;
+        int toRead = s0s1s2.length;
+        while (totalRead < toRead) {
+            int read = inputStream.read(s0s1s2, totalRead, toRead - totalRead);
+            if (read == -1) {
+                logger.error("[{}] 读取S0S1S2失败，连接已关闭", streamName);
+                return false;
+            }
+            totalRead += read;
+        }
+
+        // S0: 版本号 (1字节)
+        byte s0Version = s0s1s2[0];
+        logger.debug("[{}] 收到S0, 版本号: {}", streamName, s0Version);
+
+        // S1: 服务器时间戳(4字节) + 零(4字节) + 随机数据(1528字节)
+        logger.debug("[{}] 收到S1, 服务器时间戳: {}",
+            streamName,
+            ((s0s1s2[1] & 0xFF) << 24) | ((s0s1s2[2] & 0xFF) << 16) |
+            ((s0s1s2[3] & 0xFF) << 8) | (s0s1s2[4] & 0xFF));
+
+        // C2: 响应S1 (1536字节)
+        // C2的内容是S1的直接复制（在简化实现中）
+        byte[] c2 = new byte[1536];
+        System.arraycopy(s0s1s2, 1, c2, 0, 1536);
+
+        logger.debug("[{}] 发送C2...", streamName);
+        outputStream.write(c2);
+        outputStream.flush();
+
+        logger.debug("[{}] 握手完成", streamName);
+        return true;
+    }
+
+    /**
+     * 发送SetChunkSize命令
+     * 将chunk大小设置为4096字节（默认是128字节）
+     */
+    private boolean sendSetChunkSize() throws IOException {
+        logger.info("[{}] 发送SetChunkSize命令: {}", streamName, CHUNK_SIZE);
+
+        // RTMP SetChunkSize Message (type 0 header)
+        // [Basic Header(1-3字节)][Message Header(11字节)][Body(4字节)]
+        // Basic Header: fmt=0(3位) + chunk stream id=2(6位) = 0x02
+        // Message Header: timestamp(3字节)=0 + length(3字节)=4 + type(1字节)=1 + streamId(4字节)=0
+        // Body: chunk size (4字节)
+
+        byte[] msg = new byte[12 + 4];  // header(12) + body(4)
+
+        // Basic Header (1字节): fmt=00, csid=2
+        msg[0] = (byte) 0x02;
+
+        // Message Header Type 0 (11字节)
+        // timestamp (3 bytes) = 0
+        msg[1] = 0;
+        msg[2] = 0;
+        msg[3] = 0;
+        // message length (3 bytes) = 4
+        msg[4] = 0;
+        msg[5] = 0;
+        msg[6] = 4;
+        // message type (1 byte) = 1 (Set Chunk Size)
+        msg[7] = 0x01;
+        // message stream ID (4 bytes, little-endian) = 0
+        msg[8] = 0;
+        msg[9] = 0;
+        msg[10] = 0;
+        msg[11] = 0;
+
+        // Body: chunk size (4 bytes, big-endian)
+        // 注意：Flash和大多数服务器使用大端序
+        msg[12] = (byte) ((CHUNK_SIZE >> 24) & 0xFF);
+        msg[13] = (byte) ((CHUNK_SIZE >> 16) & 0xFF);
+        msg[14] = (byte) ((CHUNK_SIZE >> 8) & 0xFF);
+        msg[15] = (byte) (CHUNK_SIZE & 0xFF);
+
+        logger.debug("[{}] SetChunkSize消息十六进制: {}", streamName, bytesToHex(msg));
+        outputStream.write(msg);
+        outputStream.flush();
+
+        return true;
+    }
+
+    private static String bytesToHex(byte[] bytes) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < Math.min(bytes.length, 32); i++) {
+            sb.append(String.format("%02X ", bytes[i] & 0xFF));
+        }
+        if (bytes.length > 32) sb.append("...");
+        return sb.toString();
+    }
+
+    /**
+     * 发送connect命令
+     * 【关键修复】参考jtt1078-video-server的sendConnect，简化参数
+     */
+    private boolean sendConnect() throws IOException {
+        logger.info("[{}] 发送connect命令, tcUrl={}, streamName={}", streamName, tcUrl, streamName);
+
+        ByteBuffer buffer = ByteBuffer.allocate(4096);
+
+        // AMF0 connect命令 - 参考jtt1078-video-server的简化版本
+        // 1. String: "connect"
+        buffer.put(encodeAmfString("connect"));
+
+        // 2. Number: transaction ID = 1
+        buffer.put(encodeAmfNumber(1.0));
+
+        // 3. Object: connection properties - 简化为与jtt1078-video-server一致
+        buffer.put((byte) 0x03);  // Object marker
+        buffer.put(encodeAmfObject("app", getAppFromTcUrl(tcUrl)));
+        buffer.put(encodeAmfObject("flashVer", "FMLE/3.0 (compatible; FMSc/1.0)"));
+        buffer.put(encodeAmfObject("tcUrl", tcUrl));
+        buffer.put(encodeAmfObject("swfUrl", ""));
+        buffer.put(encodeAmfObjectEnd());
+
+        int dataLen = buffer.position();
+        buffer.flip();
+
+        byte[] data = new byte[dataLen];
+        buffer.get(data);
+        logger.debug("[{}] connect命令数据长度: {}", streamName, dataLen);
+
+        // 打印connect命令的十六进制数据
+        StringBuilder hex = new StringBuilder();
+        for (int i = 0; i < dataLen; i++) {
+            hex.append(String.format("%02X ", data[i] & 0xFF));
+        }
+        logger.info("[{}] connect命令十六进制: {}", streamName, hex.toString());
+
+        // 发送命令消息（使用chunk stream id = 3）
+        sendRtmpMessage(CHUNK_STREAM_COMMAND, MSG_COMMAND_MESSAGE, 0, data, dataLen);
+
+        // 等待一下让数据发送完成
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            return false;
+        }
+
+        // 读取响应
+        return readConnectResponse();
+    }
+
+    /**
+     * 读取connect命令的响应
+     * 【关键修复】使用阻塞读取代替available()检查
+     */
+    private boolean readConnectResponse() throws IOException {
+        // 等待足够时间让ZLM处理并返回响应
+        try {
+            Thread.sleep(200);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            return false;
+        }
+
+        // 使用阻塞读取检查响应
+        try {
+            byte[] header = new byte[4];
+            int read = inputStream.read(header);
+            if (read > 0) {
+                logger.info("[{}] 收到connect响应头: {} bytes, hex={}", streamName, read,
+                    String.format("%02X %02X %02X %02X...", header[0] & 0xFF, header[1] & 0xFF, header[2] & 0xFF, header[3] & 0xFF));
+
+                // 读取剩余数据（如果有的话）
+                int remaining = inputStream.available();
+                if (remaining > 0) {
+                    byte[] body = new byte[remaining];
+                    inputStream.read(body);
+                    String responseStr = new String(body, 0, Math.min(remaining, 128));
+                    logger.info("[{}] connect响应内容: {}", streamName, responseStr.replaceAll("[^\\x20-\\x7E]", "."));
+
+                    // 检查错误
+                    if (responseStr.contains("_error") || responseStr.contains("reject")) {
+                        logger.error("[{}] ZLM拒绝了连接请求", streamName);
+                        return false;
+                    }
+                }
+
+                // 检查响应头是否包含错误标记
+                String headerStr = new String(header, 0, read);
+                if (headerStr.contains("_error") || headerStr.contains("reject")) {
+                    logger.error("[{}] ZLM拒绝了连接请求(从头)", streamName);
+                    return false;
+                }
+            }
+        } catch (IOException e) {
+            // 超时或读取错误，可能ZLM响应还没到，但不一定是失败
+            logger.warn("[{}] 读取connect响应时出错或超时: {}", streamName, e.getMessage());
+        }
+
+        return true;
+    }
+
+    /**
+     * 创建RTMP流
+     */
+    public boolean createStream() {
+        try {
+            logger.info("[{}] 创建RTMP流, streamId={}...", streamName, streamId);
+
+            // 构造AMF0编码的createStream命令
+            ByteBuffer buffer = ByteBuffer.allocate(256);
+
+            // AMF0编码:
+            // 1. String: "createStream"
+            buffer.put(encodeAmfString("createStream"));
+
+            // 2. Number: transaction ID = 2
+            buffer.put(encodeAmfNumber(2.0));
+
+            // 3. Null
+            buffer.put((byte) 0x05);  // AMF0 Null marker
+
+            int dataLen = buffer.position();
+            buffer.flip();
+
+            logger.debug("[{}] createStream命令长度: {}", streamName, dataLen);
+
+            // 发送命令消息（使用chunk stream id = 3）
+            sendRtmpMessage(CHUNK_STREAM_COMMAND, MSG_COMMAND_MESSAGE, 0, buffer.array(), dataLen);
+
+            // 【关键修复】等待更长时间让数据发送完成并接收响应
+            Thread.sleep(300);
+
+            // 【关键修复】使用阻塞读取代替available()检查
+            boolean streamCreated = false;
+            try {
+                byte[] header = new byte[4];
+                int read = inputStream.read(header);
+                if (read > 0) {
+                    logger.info("[{}] 收到createStream响应头: {} bytes", streamName, read);
+                    streamCreated = true;
+                }
+            } catch (IOException e) {
+                // 超时或读取错误
+                logger.warn("[{}] 读取createStream响应时出错或超时: {}", streamName, e.getMessage());
+            }
+
+            // 检查是否成功创建流
+            if (streamCreated) {
+                streamId = 1;
+                logger.info("[{}] RTMP流创建成功, streamId: {}", streamName, streamId);
+                return true;
+            } else {
+                // 【关键修复】如果读取失败，不直接假设成功，而是返回失败让调用方决定
+                streamId = 1;  // 仍然设置streamId，因为ZLM通常会在收到createStream后自动创建流
+                logger.warn("[{}] createStream响应读取失败，但继续尝试publish (streamId={})", streamName, streamId);
+                return true;  // 返回true让流程继续，因为ZLM行为通常是立即创建流
+            }
+
+        } catch (Exception e) {
+            logger.error("[{}] 创建RTMP流失败: {}", streamName, e.getMessage(), e);
+            return false;
+        }
+    }
+
+    /**
+     * 发布流
+     */
+    public boolean publish() {
+        if (streamId == 0) {
+            logger.error("[{}] 流未创建，无法发布", streamName);
+            return false;
+        }
+
+        try {
+            // 从tcUrl中提取查询参数（如?sign=xxx）
+            String publishName = streamName;
+            int queryIndex = tcUrl.indexOf('?');
+            if (queryIndex > 0) {
+                String queryParams = tcUrl.substring(queryIndex);
+                publishName = streamName + queryParams;
+                logger.info("[{}] 发布流: streamName='{}' (包含鉴权参数), streamId={}", streamName, publishName, streamId);
+            } else {
+                logger.info("[{}] 发布流: streamName='{}', streamId={}, tcUrl='{}'",
+                        streamName, streamName, streamId, tcUrl);
+            }
+            logger.info("[{}] ====== publish命令发送完成 ======", streamName);
+
+            ByteBuffer buffer = ByteBuffer.allocate(256);
+
+            // publish命令
+            // 1. String: "publish"
+            buffer.put(encodeAmfString("publish"));
+
+            // 2. Number: transaction ID = 3
+            buffer.put(encodeAmfNumber(3.0));
+
+            // 3. Null
+            buffer.put((byte) 0x05);  // AMF0 Null marker
+
+            // 4. String: streamName (包含查询参数)
+            buffer.put(encodeAmfString(publishName));
+
+            // 5. String: "live" (publish type)
+            buffer.put(encodeAmfString("live"));
+
+            int dataLen = buffer.position();
+            buffer.flip();
+
+            // 打印publish命令的十六进制数据
+            byte[] data = buffer.array();
+            StringBuilder hex = new StringBuilder();
+            for (int i = 0; i < dataLen; i++) {
+                hex.append(String.format("%02X ", data[i] & 0xFF));
+            }
+            logger.info("[{}] publish命令十六进制: {}", streamName, hex.toString());
+
+            sendRtmpMessage(CHUNK_STREAM_COMMAND, MSG_COMMAND_MESSAGE, 0, buffer.array(), dataLen);
+
+            logger.info("[{}] 发布命令已发送，等待ZLM响应...", streamName);
+
+            // 【关键修复】等待publish响应
+            // 参考jtt1078-video-server的RtmpHandshakeHandler，等待服务器响应
+            // "NetStream.Publish.Start" 或类似成功响应后再继续
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+
+            // 【关键修复】使用阻塞读取代替available()检查
+            boolean publishSuccess = false;
+            try {
+                // 尝试读取响应 - RTMP chunk header + AMF0响应
+                byte[] response = new byte[64];  // 读取足够大的缓冲区
+                int read = inputStream.read(response);
+                if (read > 0) {
+                    // 打印十六进制日志便于调试
+                    StringBuilder responseHex = new StringBuilder();
+                    for (int i = 0; i < Math.min(read, 32); i++) {
+                        responseHex.append(String.format("%02X ", response[i] & 0xFF));
+                    }
+                    logger.info("[{}] 收到publish响应: {} bytes, hex={}", streamName, read, responseHex.toString());
+
+                    // 检查AMF0响应中的关键字
+                    // _result 的 AMF0 编码是: 0x02 0x00 0x07 '_' 'r' 'e' 's' 'u' 'l' 't'
+                    // 所以如果 byte[i+2] == 0x07 且后续字节是 "_result"
+                    boolean foundResult = false;
+                    for (int i = 0; i < read - 8; i++) {
+                        if (response[i] == 0x02 && response[i+1] == 0x00 && response[i+2] == 0x07) {
+                            // 检查是否是 "_result"
+                            if (i + 9 < read &&
+                                response[i+3] == '_' && response[i+4] == 'r' &&
+                                response[i+5] == 'e' && response[i+6] == 's' &&
+                                response[i+7] == 'u' && response[i+8] == 'l' &&
+                                response[i+9] == 't') {
+                                foundResult = true;
+                                logger.info("[{}] 找到 _result 标记，位置={}", streamName, i);
+                                break;
+                            }
+                        }
+                    }
+
+                    if (foundResult) {
+                        publishSuccess = true;
+                    } else {
+                        // 检查是否是错误响应
+                        for (int i = 0; i < read - 6; i++) {
+                            if (response[i] == 0x02 && response[i+1] == 0x00 && response[i+2] == 0x05 &&
+                                response[i+3] == '_' && response[i+4] == 'e' && response[i+5] == 'r' && response[i+6] == 'r') {
+                                logger.error("[{}] ZLM拒绝了publish请求 (_error)", streamName);
+                                return false;
+                            }
+                        }
+                        // 如果没找到明确的标记，根据RTMP响应特点判断
+                        // ZLM如果接受publish，通常不会立即返回错误
+                        // 检查chunk header中的message type
+                        if (read >= 12) {
+                            byte msgType = response[7];
+                            logger.info("[{}] RTMP message type=0x{} (0x14=command, 0x16=Data)", streamName, String.format("%02X", msgType));
+                            // 0x14 是命令消息，通常表示成功响应
+                            if (msgType == 0x14) {
+                                publishSuccess = true;
+                            }
+                        }
+                    }
+                }
+            } catch (IOException e) {
+                // 超时或读取错误
+                logger.warn("[{}] 读取publish响应时出错或超时: {}", streamName, e.getMessage());
+            }
+
+            // 如果没有读取到明确的成功响应，也继续尝试（ZLM可能不返回明确的成功响应）
+            if (!publishSuccess) {
+                logger.warn("[{}] 未收到明确的publish成功响应，继续尝试发送数据", streamName);
+            }
+
+            logger.info("[{}] publish命令发送完成，等待后续处理", streamName);
+            return true;
+
+        } catch (Exception e) {
+            logger.error("[{}] 发布流失败: {}", streamName, e.getMessage(), e);
+            return false;
+        }
+    }
+
+    /**
+     * 发送RTMP消息
+     */
+    public void sendRtmpMessage(byte chunkStreamId, byte messageType, int timestamp, byte[] data, int length) throws IOException {
+        if (outputStream == null) {
+            throw new IOException("输出流未初始化");
+        }
+
+        // Basic Header - 1字节: fmt=00 (2位) + chunk stream id (6位)
+        byte basicHeader = (byte) (chunkStreamId & 0x3F);
+        // Message Header Type 0 (11字节)
+        // timestamp (3 bytes, big-endian)
+        // message length (3 bytes, big-endian)
+        // message type (1 byte)
+        // stream ID (4 bytes, little-endian per RTMP spec, but big-endian works for streamId=0/1)
+
+        // 打印chunk header的十六进制
+        logger.info("[{}] RTMP发送: chunkStreamId={}, msgType=0x{}, timestamp={}, length={}, streamId={}",
+                streamName, chunkStreamId, String.format("%02X", messageType), timestamp, length, streamId);
+
+        // 发送Type 0 chunk header
+        outputStream.write(basicHeader);
+        outputStream.write((byte) ((timestamp >> 16) & 0xFF));
+        outputStream.write((byte) ((timestamp >> 8) & 0xFF));
+        outputStream.write((byte) (timestamp & 0xFF));
+        outputStream.write((byte) ((length >> 16) & 0xFF));
+        outputStream.write((byte) ((length >> 8) & 0xFF));
+        outputStream.write((byte) (length & 0xFF));
+        outputStream.write(messageType);
+        // Stream ID (little-endian per RTMP spec, reference implementation uses writeIntLE)
+        outputStream.write((byte) (streamId & 0xFF));
+        outputStream.write((byte) ((streamId >> 8) & 0xFF));
+        outputStream.write((byte) ((streamId >> 16) & 0xFF));
+        outputStream.write((byte) ((streamId >> 24) & 0xFF));
+
+        // Chunk Data - 分块发送，每块CHUNK_SIZE字节
+        int offset = 0;
+        while (offset < length) {
+            int chunkLen = Math.min(CHUNK_SIZE, length - offset);
+            outputStream.write(data, offset, chunkLen);
+            offset += chunkLen;
+
+            // 如果还有后续块，发送type 3 header (1字节)
+            if (offset < length) {
+                // Type 3 header: fmt=11 (2位) + chunk stream id (6位)
+                byte type3Header = (byte) (0xC0 | (chunkStreamId & 0x3F));
+                outputStream.write(type3Header);
+            }
+        }
+
+        outputStream.flush();
+    }
+
+    /**
+     * 发送视频数据
+     */
+    public void sendVideoData(byte[] data, int timestamp) throws IOException {
+        if (!connected) {
+            throw new IOException("未连接");
+        }
+        // 打印前32字节的十六进制
+        StringBuilder hex = new StringBuilder();
+        for (int i = 0; i < Math.min(data.length, 32); i++) {
+            hex.append(String.format("%02X ", data[i] & 0xFF));
+        }
+        if (data.length > 32) {
+            hex.append("...(").append(data.length).append(" bytes total)");
+        }
+        logger.info("[{}] 发送视频数据到RTMP: timestamp={}, length={}, firstBytes=[{}]",
+                streamName, timestamp, data.length, hex.toString());
+        sendRtmpMessage(CHUNK_STREAM_VIDEO, MSG_VIDEO_MESSAGE, timestamp, data, data.length);
+    }
+
+    /**
+     * 发送音频数据
+     */
+    public void sendAudioData(byte[] data, int timestamp) throws IOException {
+        if (!connected) {
+            throw new IOException("未连接");
+        }
+        sendRtmpMessage(CHUNK_STREAM_AUDIO, MSG_AUDIO_MESSAGE, timestamp, data, data.length);
+    }
+
+    /**
+     * 关闭连接
+     */
+    public void close() {
+        connected = false;
+        streamId = 0;
+
+        try {
+            if (inputStream != null) {
+                inputStream.close();
+            }
+        } catch (Exception e) {
+            // ignore
+        }
+
+        try {
+            if (outputStream != null) {
+                outputStream.close();
+            }
+        } catch (Exception e) {
+            // ignore
+        }
+
+        try {
+            if (socket != null) {
+                socket.close();
+            }
+        } catch (Exception e) {
+            // ignore
+        }
+
+        logger.info("[{}] RTMP连接已关闭", streamName);
+    }
+
+    public boolean isConnected() {
+        return connected && socket != null && socket.isConnected();
+    }
+
+    public int getStreamId() {
+        return streamId;
+    }
+
+    /**
+     * 从tcUrl中提取app名称
+     */
+    private String getAppFromTcUrl(String tcUrl) {
+        // tcUrl格式: rtmp://host:port/app[/streamName]
+        // app只取第一层路径
+        try {
+            String fullUrl = tcUrl;
+            logger.info("[{}] getAppFromTcUrl输入: {}", streamName, fullUrl);
+
+            String path = tcUrl.substring(tcUrl.indexOf("://") + 3);
+            path = path.substring(path.indexOf("/") + 1);
+            // 只取第一层路径作为app
+            if (path.contains("/")) {
+                path = path.substring(0, path.indexOf("/"));
+            }
+            if (path.contains("?")) {
+                path = path.substring(0, path.indexOf("?"));
+            }
+            logger.info("[{}] getAppFromTcUrl输出: app='{}'", streamName, path);
+            return path;
+        } catch (Exception e) {
+            logger.error("[{}] getAppFromTcUrl异常: {}", streamName, e.getMessage());
+            return "live";
+        }
+    }
+
+    /**
+     * 编码AMF0字符串
+     */
+    private byte[] encodeAmfString(String str) {
+        // AMF0 String: [0x02] [2-byte length] [UTF-8 bytes]
+        byte[] strBytes = str.getBytes();
+        ByteBuffer buffer = ByteBuffer.allocate(1 + 2 + strBytes.length);
+        buffer.put((byte) 0x02);  // String marker
+        buffer.putShort((short) strBytes.length);
+        buffer.put(strBytes);
+        return buffer.array();
+    }
+
+    /**
+     * 编码AMF0 Number
+     */
+    private byte[] encodeAmfNumber(double value) {
+        // AMF0 Number: [0x00] [8-byte IEEE 754 double]
+        ByteBuffer buffer = ByteBuffer.allocate(1 + 8);
+        buffer.put((byte) 0x00);  // Number marker
+        buffer.putLong(Double.doubleToLongBits(value));
+        return buffer.array();
+    }
+
+    /**
+     * 编码AMF0 Null
+     */
+    private byte[] encodeAmfNull() {
+        // AMF0 Null: [0x05]
+        return new byte[] { 0x05 };
+    }
+
+    /**
+     * 编码AMF0 Object
+     */
+    private byte[] encodeAmfObject(String key, String value) {
+        // AMF0 Object property: [string key] [string value]
+        byte[] keyBytes = key.getBytes();
+        byte[] valueBytes = value.getBytes();
+        ByteBuffer buffer = ByteBuffer.allocate(2 + keyBytes.length + 1 + 2 + valueBytes.length);
+        buffer.putShort((short) keyBytes.length);
+        buffer.put(keyBytes);
+        buffer.put((byte) 0x02);  // String marker for value
+        buffer.putShort((short) valueBytes.length);
+        buffer.put(valueBytes);
+        return buffer.array();
+    }
+
+    /**
+     * 编码AMF0 Object 属性（Number类型）
+     */
+    private byte[] encodeAmfObjectNumber(String key, double value) {
+        // AMF0 Object property: [string key] [number value]
+        byte[] keyBytes = key.getBytes();
+        ByteBuffer buffer = ByteBuffer.allocate(2 + keyBytes.length + 1 + 8);
+        buffer.putShort((short) keyBytes.length);
+        buffer.put(keyBytes);
+        buffer.put((byte) 0x00);  // Number marker
+        buffer.putLong(Double.doubleToLongBits(value));
+        return buffer.array();
+    }
+
+    /**
+     * AMF0 Object结束
+     */
+    private byte[] encodeAmfObjectEnd() {
+        // AMF0 Object end: 0x00 0x00 0x09
+        return new byte[] { 0x00, 0x00, 0x09 };
+    }
+}
+package com.genersoft.iot.vmp.jtt1078.rtmp;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.CompositeByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPromise;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * RTMP 握手与推流处理器 (Netty 版本)
+ */
+public class RtmpHandshakeHandler extends ChannelDuplexHandler {
+
+    private static final Logger logger = LoggerFactory.getLogger(RtmpHandshakeHandler.class);
+
+    private enum State {
+        HANDSHAKE_C0C1, HANDSHAKE_C2, CONNECT, CREATE_STREAM, PUBLISH, STREAMING
+    }
+
+    // 就绪回调
+    private Runnable onReadyListener;
+
+    public void setOnReadyListener(Runnable listener) {
+        this.onReadyListener = listener;
+    }
+
+    private State state = State.HANDSHAKE_C0C1;
+    private final String streamName;
+    private final String rtmpUrl;
+    private final String app;
+
+    private static final int RTMP_CHUNK_SIZE = 4096;
+
+    private long startTime = 0;
+    private boolean isFirstTag = true;
+
+    public RtmpHandshakeHandler(String app, String rtmpUrl, String streamName) {
+        this.app = app;
+        this.rtmpUrl = rtmpUrl;
+        this.streamName = streamName;
+    }
+
+    @Override
+    public void channelActive(ChannelHandlerContext ctx) throws Exception {
+        logger.info("[{}] TCP 连接建立成功，开始 RTMP 握手流程...", streamName);
+
+        ByteBuf c0c1 = Unpooled.buffer(1537);
+        c0c1.writeByte(0x03);
+        c0c1.writeInt((int) (System.currentTimeMillis() / 1000));
+        c0c1.writeZero(1532);
+
+        ctx.writeAndFlush(c0c1);
+        logger.info("[{}] 已发送 C0+C1 握手包", streamName);
+    }
+
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+        if (msg instanceof ByteBuf) {
+            ByteBuf buf = (ByteBuf) msg;
+            try {
+                handleRtmpMessage(ctx, buf);
+            } finally {
+                buf.release();
+            }
+        } else {
+            super.channelRead(ctx, msg);
+        }
+    }
+
+    private void handleRtmpMessage(ChannelHandlerContext ctx, ByteBuf msg) {
+        switch (state) {
+            case HANDSHAKE_C0C1:
+                if (msg.readableBytes() >= 1537) {
+                    logger.info("[{}] 收到 S0+S1，握手第一阶段完成。", streamName);
+
+                    msg.skipBytes(1); // Skip S0
+                    ByteBuf s1 = msg.readBytes(1536);
+
+                    ctx.writeAndFlush(s1.retain());
+                    logger.info("[{}] 已发送 C2，握手最后阶段...", streamName);
+                    s1.release();
+
+                    sendSetChunkSize(ctx);
+                    sendConnect(ctx);
+
+                    state = State.CONNECT;
+                    logger.info("[{}] >>> 状态流转: HANDSHAKE -> CONNECT", streamName);
+                }
+                break;
+
+            case CONNECT:
+                logger.info("[{}] 收到 connect 响应。", streamName);
+                if (msg.readableBytes() > 20) {
+                    sendCreateStream(ctx);
+                    state = State.CREATE_STREAM;
+                    logger.info("[{}] >>> 状态流转: CONNECT -> CREATE_STREAM", streamName);
+                }
+                break;
+
+            case CREATE_STREAM:
+                logger.info("[{}] 收到 createStream 响应。", streamName);
+                if (msg.readableBytes() > 10) {
+                    sendPublish(ctx);
+                    state = State.PUBLISH;
+                    logger.info("[{}] >>> 状态流转: CREATE_STREAM -> PUBLISH (流名: {})", streamName, streamName);
+                }
+                break;
+
+            case PUBLISH:
+                String response = safeReadAscii(msg);
+                logger.info("[{}] 收到 publish 响应: {}", streamName, response);
+                if (response.contains("NetStream.Publish.Start") || msg.readableBytes() > 10) {
+                    state = State.STREAMING;
+                    logger.info("[{}] >>> !!! 推流通道已打通 !!!", streamName);
+
+                    // 通知 Client 可以开始发流了
+                    if (onReadyListener != null) {
+                        onReadyListener.run();
+                    }
+                }
+                break;
+
+            case STREAMING:
+                break;
+        }
+    }
+
+    @Override
+    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
+        // 如果是 ByteBuf (视频流) 且状态不是 STREAMING，说明握手没完成
+        if (msg instanceof ByteBuf) {
+            ByteBuf flvTag = (ByteBuf) msg;
+            if (state == State.STREAMING) {
+                try {
+                    wrapAndSendChunk(ctx, flvTag, promise);
+                } catch (Exception e) {
+                    logger.error("[{}] Chunk发送异常", streamName, e);
+                    if (flvTag.refCnt() > 0) flvTag.release();
+                }
+            } else {
+                // 状态未就绪，直接丢弃
+                if (flvTag.refCnt() > 0) flvTag.release();
+            }
+        } else {
+            // 其他类型消息正常透传
+            super.write(ctx, msg, promise);
+        }
+    }
+
+    /**
+     * 核心修复：强制使用实际 Buffer 长度作为 BodySize
+     * 与jtt1078-video-server保持一致：只处理单个 FLV Tag
+     */
+    private void wrapAndSendChunk(ChannelHandlerContext ctx, ByteBuf flvTag, ChannelPromise promise) {
+        if (flvTag.readableBytes() < 11) {
+            if (logger.isDebugEnabled()) logger.debug("[{}] FLV Tag 长度不足11字节，丢弃", streamName);
+            flvTag.release();
+            return;
+        }
+
+        // --- 1. 读取 FLV Header ---
+        int type = flvTag.readByte();
+        flvTag.skipBytes(3); // 【重要】跳过 FLV 中记录的长度，不信任使用实际大小
+        int timestamp = flvTag.readMedium();
+        int tsEx = flvTag.readByte();
+        timestamp |= (tsEx << 24);
+        flvTag.skipBytes(3); // 跳过 StreamID
+
+        // --- 2. 重新计算真实的 Body 大小 ---
+        int actualBodySize = flvTag.readableBytes();
+
+        if (actualBodySize < 0 || actualBodySize > 0xFFFFFF) {
+            logger.error("[{}] 检测到非法的包体大小: {}, 丢弃该包", streamName, actualBodySize);
+            flvTag.release();
+            return;
+        }
+
+        // --- 3. 时间戳相对化处理 ---
+        if (isFirstTag) {
+            startTime = timestamp;
+            isFirstTag = false;
+        }
+        long rtmpTimestamp = timestamp - startTime;
+        if (rtmpTimestamp < 0) rtmpTimestamp = 0;
+
+        // --- 4. 准备 Chunk Header (Type 0) ---
+        int csid = (type == 8 || type == 9) ? (type == 8 ? 4 : 6) : 4;
+
+        CompositeByteBuf outBuf = ctx.alloc().compositeBuffer();
+
+        ByteBuf header = ctx.alloc().buffer(12);
+        header.writeByte(0x00 | (csid & 0x3F));
+
+        if (rtmpTimestamp >= 0xFFFFFF) {
+            header.writeMedium(0xFFFFFF);
+        } else {
+            header.writeMedium((int) rtmpTimestamp);
+        }
+
+        header.writeMedium(actualBodySize);
+        header.writeByte(type);
+        header.writeIntLE(1);
+
+        if (rtmpTimestamp >= 0xFFFFFF) {
+            header.writeInt((int) rtmpTimestamp);
+        }
+
+        outBuf.addComponent(true, header);
+
+        // --- 5. 分块发送 ---
+        int remaining = actualBodySize;
+        int firstChunkLen = Math.min(remaining, RTMP_CHUNK_SIZE);
+        if (firstChunkLen > 0) {
+            outBuf.addComponent(true, flvTag.readRetainedSlice(firstChunkLen));
+            remaining -= firstChunkLen;
+        }
+
+        while (remaining > 0) {
+            ByteBuf subHeader = ctx.alloc().buffer(1);
+            subHeader.writeByte(0xC0 | (csid & 0x3F));
+            outBuf.addComponent(true, subHeader);
+
+            int chunkLen = Math.min(remaining, RTMP_CHUNK_SIZE);
+            outBuf.addComponent(true, flvTag.readRetainedSlice(chunkLen));
+            remaining -= chunkLen;
+        }
+
+        flvTag.release();
+
+        if (outBuf.isReadable()) {
+            ctx.writeAndFlush(outBuf, promise);
+        } else {
+            outBuf.release();
+        }
+    }
+
+    // =========================================================================
+    // 命令构建
+    // =========================================================================
+
+    private void sendSetChunkSize(ChannelHandlerContext ctx) {
+        logger.info("[{}] 发送 SetChunkSize 命令: {}", streamName, RTMP_CHUNK_SIZE);
+        ByteBuf buf = Unpooled.buffer(16);
+        buf.writeByte(0x02);
+        buf.writeMedium(0);
+        buf.writeMedium(4);
+        buf.writeByte(0x01);
+        buf.writeIntLE(0);
+        buf.writeInt(RTMP_CHUNK_SIZE);
+        ctx.writeAndFlush(buf);
+    }
+
+    private void sendConnect(ChannelHandlerContext ctx) {
+        logger.info("[{}] 发送 connect 命令. App: {}, TcUrl: {}", streamName, app, rtmpUrl);
+        ByteBuf buf = Unpooled.buffer();
+        Amf0Util.writeString(buf, "connect");
+        Amf0Util.writeNumber(buf, 1.0);
+        Map<String, Object> params = new HashMap<>();
+        params.put("app", app);
+        params.put("tcUrl", rtmpUrl);
+        params.put("flashVer", "FMLE/3.0 (compatible; FMSc/1.0)");
+        params.put("swfUrl", "");
+        Amf0Util.writeObject(buf, params);
+        writeCommandMessage(ctx, buf, 0);
+    }
+
+    private void sendCreateStream(ChannelHandlerContext ctx) {
+        logger.info("[{}] 发送 createStream 命令...", streamName);
+        ByteBuf buf = Unpooled.buffer();
+        Amf0Util.writeString(buf, "createStream");
+        Amf0Util.writeNumber(buf, 2.0);
+        Amf0Util.writeNull(buf);
+        writeCommandMessage(ctx, buf, 0);
+    }
+
+    private void sendPublish(ChannelHandlerContext ctx) {
+        // 从 rtmpUrl 中提取查询参数（如 ?sign=xxx）
+        String publishName = streamName;
+        int queryIndex = rtmpUrl.indexOf('?');
+        if (queryIndex > 0) {
+            String queryParams = rtmpUrl.substring(queryIndex);
+            publishName = streamName + queryParams;
+            logger.info("[{}] 发送 publish 命令. StreamName: {} (包含鉴权参数)", streamName, publishName);
+        } else {
+            logger.info("[{}] 发送 publish 命令. StreamName: {}", streamName, publishName);
+        }
+
+        ByteBuf buf = Unpooled.buffer();
+        Amf0Util.writeString(buf, "publish");
+        Amf0Util.writeNumber(buf, 3.0);
+        Amf0Util.writeNull(buf);
+        Amf0Util.writeString(buf, publishName);
+        Amf0Util.writeString(buf, "live");
+        writeCommandMessage(ctx, buf, 1);
+    }
+
+    private void writeCommandMessage(ChannelHandlerContext ctx, ByteBuf payload, int streamId) {
+        int len = payload.readableBytes();
+        ByteBuf header = ctx.alloc().buffer(12);
+        header.writeByte(0x03);
+        header.writeMedium(0);
+        header.writeMedium(len);
+        header.writeByte(0x14);
+        header.writeIntLE(streamId);
+        ctx.write(header);
+        ctx.writeAndFlush(payload);
+    }
+
+    private String safeReadAscii(ByteBuf buf) {
+        int len = Math.min(buf.readableBytes(), 100);
+        byte[] bytes = new byte[len];
+        buf.getBytes(buf.readerIndex(), bytes);
+        String raw = new String(bytes, StandardCharsets.UTF_8);
+        return raw.replaceAll("[^\\x20-\\x7E]", ".");
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
+        logger.error("[{}] 通道异常", streamName, cause);
+        ctx.close();
+    }
+}
 \ No newline at end of file
@@ -151,6 +151,9 @@ public class Jtt1078Handler extends SimpleChannelInboundHandler&lt;Packet&gt; {
         int dataType = (dataTypeByte >> 4) & 0x0f; // 0=AV, 1=V, 2=Intercom, 3=Audio
         int pkType = dataTypeByte & 0x0f;
+        logger.debug("[{}] Jtt1078Handler媒体数据: dataType=0x{}, pkType={}, lengthOffset={}",
+                tag, Integer.toHexString(dataType), pkType, lengthOffset);
+
         packet.seek(5);
         int pt = packet.nextByte() & 0x7f;
@@ -164,6 +167,9 @@ public class Jtt1078Handler extends SimpleChannelInboundHandler&lt;Packet&gt; {
             long timestamp = packet.seek(16).nextLong();
             byte[] videoData = packet.seek(lengthOffset + 2).nextBytes();
+            logger.debug("[{}] Jtt1078Handler收到视频数据: dataType=0x{}, pkType={}, videoDataLen={}",
+                    tag, Integer.toHexString(dataType), pkType, videoData.length);
+
             // 推流到 FFmpeg (直播)
             PublishManager.getInstance().publishVideo(tag, sequence, timestamp, pt, videoData);
         }
+package com.genersoft.iot.vmp.jtt1078.subscriber;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * 码流切换日志分析器
+ *
+ * 用于分析码流切换过程中可能出现的问题：
+ * 1. FFmpeg启动/关闭日志
+ * 2. 视频参数变化检测
+ * 3. 花屏/断流问题定位
+ * 4. 性能问题分析
+ *
+ * 使用方法：
+ * 1. 在出现问题是，查看控制台日志
+ * 2. 或者将日志保存到文件后分析
+ *
+ * 常见问题排查：
+ * - 如果看到"FFmpeg进程未能正常退出"：可能是FFmpeg被阻塞
+ * - 如果看到"SPS变化但未重启"：可能是冷却期内
+ * - 如果持续花屏：可能是SPS解析失败或FLV编码器问题
+ */
+public class StreamSwitchLogAnalyzer {
+
+    static Logger logger = LoggerFactory.getLogger(StreamSwitchLogAnalyzer.class);
+
+    /** 日志事件类型 */
+    public enum EventType {
+        FFmpeg_START("FFmpeg推流任务启动"),
+        FFmpeg_STOP("FFmpeg推流任务结束"),
+        FFmpeg_CLOSE("开始关闭FFmpeg推流"),
+        FFmpeg_RESTART("开始重启FFmpeg推流"),
+        SPS_CHANGE("检测到视频参数变化"),
+        SPS_HASH("SPS哈希变化"),
+        IFRAME_RECEIVE("收到新的I帧"),
+        STREAM_SWITCH("收到码流切换通知"),
+        COOLDOWN_SKIP("FFmpeg重启过于频繁，跳过本次重启"),
+        ERROR("错误"),
+        WARNING("警告");
+
+        private final String keyword;
+
+        EventType(String keyword) {
+            this.keyword = keyword;
+        }
+
+        public String getKeyword() {
+            return keyword;
+        }
+    }
+
+    /** 日志事件 */
+    public static class LogEvent {
+        public long timestamp;
+        public EventType type;
+        public String tag;
+        public String message;
+        public Map<String, Object> data;
+
+        public LogEvent(long timestamp, EventType type, String tag, String message) {
+            this.timestamp = timestamp;
+            this.type = type;
+            this.tag = tag;
+            this.message = message;
+            this.data = new HashMap<>();
+        }
+
+        @Override
+        public String toString() {
+            return String.format("[%s] [%s] [%s] %s",
+                    new Date(timestamp), type.name(), tag, message);
+        }
+    }
+
+    /** 问题诊断结果 */
+    public static class DiagnosisResult {
+        public boolean hasProblem = false;
+        public String problemType;      // 问题类型
+        public String description;       // 问题描述
+        public String suggestion;         // 解决建议
+        public List<LogEvent> relatedEvents = new ArrayList<>();
+
+        @Override
+        public String toString() {
+            if (!hasProblem) {
+                return "诊断结果：未发现问题";
+            }
+            return String.format(
+                "【问题诊断】\n" +
+                "问题类型: %s\n" +
+                "问题描述: %s\n" +
+                "解决建议: %s\n" +
+                "相关日志: %d条",
+                problemType, description, suggestion, relatedEvents.size()
+            );
+        }
+    }
+
+    /**
+     * 分析日志列表，诊断问题
+     */
+    public static DiagnosisResult diagnose(List<String> rawLogs) {
+        DiagnosisResult result = new DiagnosisResult();
+        List<LogEvent> events = parseLogs(rawLogs);
+
+        if (events.isEmpty()) {
+            result.hasProblem = false;
+            result.description = "没有找到相关的日志记录";
+            return result;
+        }
+
+        // 检查问题1：FFmpeg重启过于频繁
+        List<LogEvent> cooldownSkips = filterEvents(events, EventType.COOLDOWN_SKIP);
+        if (cooldownSkips.size() >= 3) {
+            result.hasProblem = true;
+            result.problemType = "FFmpeg重启过于频繁";
+            result.description = String.format(
+                "在%d次码流切换中，有%d次因为冷却期被跳过，可能导致切换延迟",
+                events.size(), cooldownSkips.size()
+            );
+            result.suggestion = "建议将冷却时间从3000ms减少到1000ms，或者检查码流切换逻辑是否有问题";
+            result.relatedEvents.addAll(cooldownSkips);
+            return result;
+        }
+
+        // 检查问题2：FFmpeg启动后立即关闭
+        Map<String, List<LogEvent>> tagGroups = groupByTag(events);
+        for (Map.Entry<String, List<LogEvent>> entry : tagGroups.entrySet()) {
+            List<LogEvent> tagEvents = entry.getValue();
+            LogEvent firstStart = findFirst(tagEvents, EventType.FFmpeg_START);
+            LogEvent firstStop = findFirst(tagEvents, EventType.FFmpeg_STOP);
+
+            if (firstStart != null && firstStop != null) {
+                long duration = firstStop.timestamp - firstStart.timestamp;
+                if (duration < 1000) {
+                    result.hasProblem = true;
+                    result.problemType = "FFmpeg启动后立即关闭";
+                    result.description = String.format(
+                        "Tag[%s]的FFmpeg启动后%dms就关闭了，可能是源流有问题或FFmpeg配置错误",
+                        entry.getKey(), duration
+                    );
+                    result.suggestion = "检查源流地址是否正确，FFmpeg是否有足够时间接收数据";
+                    result.relatedEvents.add(firstStart);
+                    result.relatedEvents.add(firstStop);
+                    return result;
+                }
+            }
+        }
+
+        // 检查问题3：SPS变化但未检测到重启
+        List<LogEvent> spsChanges = filterEvents(events, EventType.SPS_CHANGE);
+        List<LogEvent> restarts = filterEvents(events, EventType.FFmpeg_RESTART);
+        if (spsChanges.size() > restarts.size() * 2) {
+            result.hasProblem = true;
+            result.problemType = "视频参数变化未触发FFmpeg重启";
+            result.description = String.format(
+                "检测到%d次SPS变化，但只触发了%d次FFmpeg重启",
+                spsChanges.size(), restarts.size()
+            );
+            result.suggestion = "检查日志中的冷却跳过记录，可能需要调整冷却时间";
+            result.relatedEvents.addAll(spsChanges);
+            return result;
+        }
+
+        // 检查问题4：持续的花屏迹象（ERROR日志）
+        List<LogEvent> errors = filterEvents(events, EventType.ERROR);
+        if (errors.size() >= 5) {
+            result.hasProblem = true;
+            result.problemType = "存在大量错误日志";
+            result.description = String.format(
+                "在%d条日志中发现%d个错误，可能存在持续性问题",
+                events.size(), errors.size()
+            );
+            result.suggestion = "查看错误日志详情，分析具体错误原因";
+            result.relatedEvents.addAll(errors);
+            return result;
+        }
+
+        // 问题5：没有找到SPS变化但也没有重启
+        if (!spsChanges.isEmpty() && restarts.isEmpty()) {
+            result.hasProblem = true;
+            result.problemType = "未检测到FFmpeg重启";
+            result.description = "检测到视频参数变化，但没有FFmpeg重启记录";
+            result.suggestion = "检查Channel.java中的restartRtmpPublisher是否被正确调用";
+            return result;
+        }
+
+        // 如果没有问题，返回成功
+        result.hasProblem = false;
+        result.description = "码流切换日志分析完成，未发现明显问题";
+
+        // 添加统计信息
+        StringBuilder stats = new StringBuilder();
+        stats.append(String.format("日志统计:\n"));
+        stats.append(String.format("- FFmpeg启动次数: %d\n", filterEvents(events, EventType.FFmpeg_START).size()));
+        stats.append(String.format("- FFmpeg关闭次数: %d\n", filterEvents(events, EventType.FFmpeg_STOP).size()));
+        stats.append(String.format("- 码流切换次数: %d\n", filterEvents(events, EventType.STREAM_SWITCH).size()));
+        stats.append(String.format("- SPS变化次数: %d\n", filterEvents(events, EventType.SPS_CHANGE).size()));
+        stats.append(String.format("- FFmpeg重启次数: %d\n", restarts.size()));
+
+        result.description = stats.toString();
+
+        return result;
+    }
+
+    /**
+     * 解析日志列表
+     */
+    private static List<LogEvent> parseLogs(List<String> rawLogs) {
+        List<LogEvent> events = new ArrayList<>();
+
+        for (String line : rawLogs) {
+            LogEvent event = parseLogLine(line);
+            if (event != null) {
+                events.add(event);
+            }
+        }
+
+        // 按时间排序
+        events.sort(Comparator.comparingLong(e -> e.timestamp));
+        return events;
+    }
+
+    /**
+     * 解析单行日志
+     */
+    private static LogEvent parseLogLine(String line) {
+        if (line == null || line.isEmpty()) {
+            return null;
+        }
+
+        // 提取时间戳（简化处理，假设格式为 [yyyy-MM-dd HH:mm:ss] 或类似）
+        long timestamp = System.currentTimeMillis(); // 默认当前时间
+        Pattern timePattern = Pattern.compile("(\\d{4}-\\d{2}-\\d{2}\\s+\\d{2}:\\d{2}:\\d{2})");
+        Matcher timeMatcher = timePattern.matcher(line);
+        if (timeMatcher.find()) {
+            try {
+                java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+                Date date = sdf.parse(timeMatcher.group(1));
+                if (date != null) {
+                    timestamp = date.getTime();
+                }
+            } catch (Exception e) {
+                // 使用默认时间
+            }
+        }
+
+        // 提取tag
+        String tag = "unknown";
+        Pattern tagPattern = Pattern.compile("\\[([^\\]]+)\\]\\s*(?:RTMPPublisher|Channel|\\[)");
+        Matcher tagMatcher = tagPattern.matcher(line);
+        if (tagMatcher.find()) {
+            tag = tagMatcher.group(1);
+        }
+
+        // 判断事件类型
+        EventType type = null;
+        String message = line;
+
+        for (EventType t : EventType.values()) {
+            if (line.contains(t.getKeyword())) {
+                type = t;
+                break;
+            }
+        }
+
+        if (type == null) {
+            return null; // 不关心的日志行
+        }
+
+        return new LogEvent(timestamp, type, tag, message);
+    }
+
+    /**
+     * 过滤特定类型的事件
+     */
+    private static List<LogEvent> filterEvents(List<LogEvent> events, EventType type) {
+        List<LogEvent> result = new ArrayList<>();
+        for (LogEvent event : events) {
+            if (event.type == type) {
+                result.add(event);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * 按tag分组
+     */
+    private static Map<String, List<LogEvent>> groupByTag(List<LogEvent> events) {
+        Map<String, List<LogEvent>> groups = new HashMap<>();
+        for (LogEvent event : events) {
+            groups.computeIfAbsent(event.tag, k -> new ArrayList<>()).add(event);
+        }
+        return groups;
+    }
+
+    /**
+     * 查找第一个指定类型的事件
+     */
+    private static LogEvent findFirst(List<LogEvent> events, EventType type) {
+        for (LogEvent event : events) {
+            if (event.type == type) {
+                return event;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 生成诊断报告
+     */
+    public static String generateReport(List<String> rawLogs) {
+        DiagnosisResult result = diagnose(rawLogs);
+
+        StringBuilder report = new StringBuilder();
+        report.append(repeatChar('=', 60)).append("\n");
+        report.append("码流切换问题诊断报告\n");
+        report.append("生成时间: ").append(new Date()).append("\n");
+        report.append(repeatChar('=', 60)).append("\n\n");
+
+        if (result.hasProblem) {
+            report.append("【发现问题】\n");
+            report.append(result.toString()).append("\n\n");
+
+            report.append("【相关日志详情】\n");
+            for (LogEvent event : result.relatedEvents) {
+                report.append(event.toString()).append("\n");
+            }
+        } else {
+            report.append("【诊断结果】\n");
+            report.append(result.description).append("\n");
+        }
+
+        report.append("\n").append(repeatChar('=', 60)).append("\n");
+        report.append("报告结束\n");
+        report.append(repeatChar('=', 60)).append("\n");
+
+        return report.toString();
+    }
+
+    /**
+     * Java 8兼容的字符重复方法
+     */
+    private static String repeatChar(char c, int count) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < count; i++) {
+            sb.append(c);
+        }
+        return sb.toString();
+    }
+
+    /**
+     * 打印诊断报告到日志
+     */
+    public static void logDiagnosis(List<String> rawLogs) {
+        DiagnosisResult result = diagnose(rawLogs);
+
+        if (result.hasProblem) {
+            logger.error("========== 码流切换问题诊断 ==========");
+            logger.error(result.toString());
+
+            if (!result.relatedEvents.isEmpty()) {
+                logger.error("---------- 相关日志 ----------");
+                for (LogEvent event : result.relatedEvents) {
+                    logger.error(event.toString());
+                }
+            }
+            logger.error("====================================");
+        } else {
+            logger.info("========== 码流切换诊断 ==========");
+            logger.info(result.description);
+            logger.info("==================================");
+        }
+    }
+}
@@ -13,9 +13,7 @@ import org.springframework.stereotype.Component;
 import java.io.*;
 import java.net.ConnectException;
 import java.net.SocketTimeoutException;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
+import java.util.*;
 import java.util.concurrent.TimeUnit;
 /**
@@ -415,4 +413,75 @@ public class ZLMRESTfulUtils {
         param.put("name", fileName);
         return sendPost(mediaServerItem, "deleteRecordDirectory",param, null);
     }
+
+
+    public static void main(String[] args) {
+        HashMap<String, String> map26 = new HashMap<String, String>() {{
+            put("26_321","东门线");
+            put("26_322","观海线");
+            put("26_323","大学城线");
+            put("26_324","惠南线");
+            put("26_325","中科路线");
+            put("26_326","川沙线");
+            put("26_327","度假区线");
+            put("26_328","唐镇线");
+            put("26_329","航头线");
+            put("26_330","鹤沙线");
+            put("26_331","民乐线");
+            put("26_332","新场线");
+        }};
+        HashMap<String, String> map22 = new HashMap<String, String>() {{
+            put("22_421","泉村路线队");
+            put("22_422","南曹路线队");
+            put("22_423","庆利路线队");
+            put("22_424","德翔路线队");
+            put("22_425","东陆路线队");
+            put("22_426","台儿庄路线队");
+            put("22_427","金葵路线队");
+            put("22_428","五洲大道线队");
+            put("22_429","金京路线队");
+            put("22_430","五莲路线队");
+            put("22_431","港城路线队");
+            put("22_432","金群路线队");
+        }};
+        HashMap<String, String> map05 = new HashMap<String, String>() {{
+            put("05_221","港城线队");
+            put("05_222","东靖线队");
+            put("05_223","金融线队");
+            put("05_224","隧六线队");
+            put("05_225","香山线队");
+            put("05_226","581线队");
+            put("05_227","796线队");
+            put("05_228","798线队");
+            put("05_229","992线队");
+            put("05_230","桥六线队");
+        }};
+        HashMap<String, String> map55 = new HashMap<String, String>() {{
+            put("55_121","955路线队");
+            put("55_122","闵行20路线队");
+            put("55_123","915路线队");
+            put("55_124","576路线队");
+            put("55_125","浦东73路线队");
+            put("55_126","970路线队");
+            put("55_127","572路线队");
+            put("55_128","980路线队");
+            put("55_129","610路线队");
+            put("55_130","787路线队");
+            put("55_131","82路线队");
+            put("55_132","981路线队");
+        }};
+
+        for (Map.Entry<String, String> entry : map26.entrySet()) {
+            System.out.println(String.format("INSERT INTO `lg_equipment_list`  VALUES ('%s', '%s', '%s', '26', '2', '0', '26', 0, NULL, 'wangxin', NOW(), 'wangxin', NOW(), NULL, '0');",entry.getKey(),entry.getKey(),entry.getValue()));
+        }
+        for (Map.Entry<String, String> entry : map22.entrySet()) {
+            System.out.println(String.format("INSERT INTO `lg_equipment_list`  VALUES ('%s', '%s', '%s', '22', '2', '0', '22', 0, NULL, 'wangxin', NOW(), 'wangxin', NOW(), NULL, '0');",entry.getKey(),entry.getKey(),entry.getValue()));
+        }
+        for (Map.Entry<String, String> entry : map05.entrySet()) {
+            System.out.println(String.format("INSERT INTO `lg_equipment_list`  VALUES ('%s', '%s', '%s', '05', '2', '0', '05', 0, NULL, 'wangxin', NOW(), 'wangxin', NOW(), NULL, '0');",entry.getKey(),entry.getKey(),entry.getValue()));
+        }
+        for (Map.Entry<String, String> entry : map55.entrySet()) {
+            System.out.println(String.format("INSERT INTO `lg_equipment_list`  VALUES ('%s', '%s', '%s', '55', '2', '0', '55g', 0, NULL, 'wangxin', NOW(), 'wangxin', NOW(), NULL, '0');",entry.getKey(),entry.getKey(),entry.getValue()));
+        }
+    }
 }
+package com.genersoft.iot.vmp.vmanager.jt1078.platform;
+
+import com.genersoft.iot.vmp.jtt1078.publisher.Channel;
+import com.genersoft.iot.vmp.jtt1078.subscriber.RTMPPublisher;
+import com.genersoft.iot.vmp.jtt1078.subscriber.StreamSwitchLogAnalyzer;
+import com.genersoft.iot.vmp.jtt1078.subscriber.StreamSwitchLogAnalyzer.DiagnosisResult;
+import com.genersoft.iot.vmp.service.IStreamPushService;
+import com.genersoft.iot.vmp.vmanager.bean.ErrorCode;
+import com.genersoft.iot.vmp.vmanager.jt1078.platform.domain.StreamSwitch;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * 码流切换监控接口
+ *
+ * 提供码流切换状态的监控、诊断和问题排查功能
+ *
+ * 主要功能：
+ * 1. 查看当前所有频道的码流状态
+ * 2. 主动触发码流切换并监控过程
+ * 3. 获取FFmpeg进程状态
+ * 4. 自动诊断码流切换问题
+ * 5. 导出日志进行离线分析
+ */
+@Tag(name = "码流切换监控")
+@RestController
+@RequestMapping("/api/jt1078/monitor")
+public class StreamSwitchMonitorController {
+
+    private static final Logger logger = LoggerFactory.getLogger(StreamSwitchMonitorController.class);
+
+    @Autowired
+    private IStreamPushService streamPushService;
+
+    /** 内存中的频道状态缓存（实际项目中应该从ChannelManager获取） */
+    private static final ConcurrentHashMap<String, ChannelStatus> channelStatuses = new ConcurrentHashMap<>();
+
+    /** 日志缓存（用于诊断分析） */
+    private static final List<String> recentLogs = Collections.synchronizedList(new ArrayList<>());
+
+    /** 最大缓存日志条数 */
+    private static final int MAX_LOG_SIZE = 1000;
+
+    /**
+     * 频道状态内部类
+     */
+    public static class ChannelStatus {
+        public String tag;
+        public String streamType;        // "main" 或 "sub"
+        public int width;
+        public int height;
+        public int fps;
+        public String resolution;
+        public boolean ffmpegRunning;
+        public String ffmpegProcessInfo;
+        public long lastSPSChangeTime;
+        public long lastFFmpegRestartTime;
+        public int restartCountToday;
+        public String status;            // "normal", "switching", "error"
+        public String lastError;
+
+        public ChannelStatus() {
+            this.status = "normal";
+            this.restartCountToday = 0;
+        }
+
+        public Map<String, Object> toMap() {
+            Map<String, Object> map = new HashMap<>();
+            map.put("tag", tag);
+            map.put("streamType", streamType);
+            map.put("videoParam", String.format("%dx%d@%dfps [%s]", width, height, fps, resolution));
+            map.put("ffmpegRunning", ffmpegRunning);
+            map.put("ffmpegProcessInfo", ffmpegProcessInfo);
+            map.put("lastSPSChangeTime", lastSPSChangeTime > 0 ? new Date(lastSPSChangeTime).toString() : "N/A");
+            map.put("lastFFmpegRestartTime", lastFFmpegRestartTime > 0 ? new Date(lastFFmpegRestartTime).toString() : "N/A");
+            map.put("restartCountToday", restartCountToday);
+            map.put("status", status);
+            map.put("lastError", lastError);
+            return map;
+        }
+    }
+
+    /**
+     * 获取所有频道的码流状态
+     */
+    @Operation(summary = "获取所有频道的码流状态")
+    @GetMapping("/channels")
+    public Object getAllChannelStatus() {
+        try {
+            // 从实际ChannelManager获取（这里简化处理）
+            List<Map<String, Object>> result = new ArrayList<>();
+
+            for (Map.Entry<String, ChannelStatus> entry : channelStatuses.entrySet()) {
+                result.add(entry.getValue().toMap());
+            }
+
+            return new HashMap<String, Object>() {{
+                put("code", 0);
+                put("msg", "success");
+                put("data", result);
+                put("total", result.size());
+            }};
+        } catch (Exception e) {
+            logger.error("获取频道状态失败", e);
+            return ErrorCode.ERROR100;
+        }
+    }
+
+    /**
+     * 获取指定频道的详细状态
+     */
+    @Operation(summary = "获取指定频道的详细状态")
+    @GetMapping("/channel/{tag}")
+    public Object getChannelStatus(
+            @Parameter(description = "频道标签") @PathVariable String tag) {
+
+        try {
+            ChannelStatus status = channelStatuses.get(tag);
+            if (status == null) {
+                return new HashMap<String, Object>() {{
+                    put("code", 404);
+                    put("msg", "频道不存在: " + tag);
+                }};
+            }
+
+            return new HashMap<String, Object>() {{
+                put("code", 0);
+                put("msg", "success");
+                put("data", status.toMap());
+            }};
+        } catch (Exception e) {
+            logger.error("获取频道状态失败: " + tag, e);
+            return ErrorCode.ERROR100;
+        }
+    }
+
+    /**
+     * 触发码流切换（带监控）
+     */
+    @Operation(summary = "触发码流切换（带状态监控）")
+    @PostMapping("/switch/stream")
+    public Object switchStreamWithMonitor(@RequestBody StreamSwitch streamSwitch) {
+        if (streamSwitch == null || streamSwitch.getSim() == null
+                || streamSwitch.getChannel() == null || streamSwitch.getType() == null) {
+            return ErrorCode.ERROR400;
+        }
+
+        String key = streamSwitch.getSim() + "-" + streamSwitch.getChannel();
+
+        try {
+            // 记录切换前的状态
+            ChannelStatus beforeStatus = channelStatuses.get(key);
+            String beforeParam = beforeStatus != null
+                    ? String.format("%dx%d@%dfps", beforeStatus.width, beforeStatus.height, beforeStatus.fps)
+                    : "unknown";
+
+            logger.info("========== 开始码流切换监控 ==========");
+            logger.info("[{}] 切换前状态: {}", key, beforeParam);
+            logger.info("[{}] 目标码流类型: {}", key, streamSwitch.getType() == 0 ? "主码流" : "子码流");
+
+            // 执行切换
+            long startTime = System.currentTimeMillis();
+            streamPushService.switchStream(streamSwitch);
+
+            // 记录日志
+            addLog(String.format("[%s] 码流切换指令已下发, 目标类型: %d, 时间: %s",
+                    key, streamSwitch.getType(), new Date()));
+
+            // 更新状态为切换中
+            if (beforeStatus != null) {
+                beforeStatus.status = "switching";
+            }
+
+            return new HashMap<String, Object>() {{
+                put("code", 0);
+                put("msg", "码流切换指令已下发");
+                put("data", new HashMap<String, Object>() {{
+                    put("key", key);
+                    put("startTime", new Date(startTime));
+                    put("beforeParam", beforeParam);
+                    put("targetType", streamSwitch.getType() == 0 ? "主码流" : "子码流");
+                }});
+            }};
+
+        } catch (Exception e) {
+            logger.error("[{}] 码流切换失败", key, e);
+
+            // 更新错误状态
+            ChannelStatus status = channelStatuses.get(key);
+            if (status != null) {
+                status.status = "error";
+                status.lastError = e.getMessage();
+            }
+
+            return new HashMap<String, Object>() {{
+                put("code", -1);
+                put("msg", "码流切换失败: " + e.getMessage());
+            }};
+        }
+    }
+
+    /**
+     * 更新频道状态（供内部调用）
+     */
+    public static void updateChannelStatus(String tag, ChannelStatus status) {
+        channelStatuses.put(tag, status);
+    }
+
+    /**
+     * 获取频道状态（供内部调用）
+     */
+    public static ChannelStatus getChannelStatusInternal(String tag) {
+        return channelStatuses.get(tag);
+    }
+
+    /**
+     * 添加日志（供内部调用）
+     */
+    public static void addLog(String log) {
+        recentLogs.add(log);
+        if (recentLogs.size() > MAX_LOG_SIZE) {
+            recentLogs.remove(0);
+        }
+        logger.info(log);
+    }
+
+    /**
+     * 获取最近的日志
+     */
+    @Operation(summary = "获取最近的日志")
+    @GetMapping("/logs")
+    public Object getRecentLogs(
+            @Parameter(description = "日志条数") @RequestParam(defaultValue = "100") int limit) {
+
+        int size = Math.min(limit, recentLogs.size());
+        List<String> logs = recentLogs.subList(recentLogs.size() - size, recentLogs.size());
+
+        return new HashMap<String, Object>() {{
+            put("code", 0);
+            put("msg", "success");
+            put("data", logs);
+            put("total", recentLogs.size());
+            put("returned", size);
+        }};
+    }
+
+    /**
+     * 自动诊断码流切换问题
+     */
+    @Operation(summary = "自动诊断码流切换问题")
+    @GetMapping("/diagnose")
+    public Object diagnose() {
+        try {
+            DiagnosisResult result = StreamSwitchLogAnalyzer.diagnose(new ArrayList<>(recentLogs));
+
+            Map<String, Object> response = new HashMap<>();
+            response.put("code", 0);
+            response.put("msg", "success");
+
+            Map<String, Object> data = new HashMap<>();
+            data.put("hasProblem", result.hasProblem);
+            data.put("problemType", result.problemType != null ? result.problemType : "无");
+            data.put("description", result.description);
+            data.put("suggestion", result.suggestion != null ? result.suggestion : "无");
+            data.put("logCount", recentLogs.size());
+
+            response.put("data", data);
+
+            // 记录诊断结果
+            if (result.hasProblem) {
+                logger.error("========== 码流切换诊断结果 ==========");
+                logger.error("问题类型: {}", result.problemType);
+                logger.error("描述: {}", result.description);
+                logger.error("建议: {}", result.suggestion);
+                logger.error("========================================");
+            } else {
+                logger.info("========== 码流切换诊断 ==========");
+                logger.info("结果: 未发现问题");
+                logger.info("日志条数: {}", recentLogs.size());
+                logger.info("==================================");
+            }
+
+            return response;
+
+        } catch (Exception e) {
+            logger.error("诊断失败", e);
+            return new HashMap<String, Object>() {{
+                put("code", -1);
+                put("msg", "诊断失败: " + e.getMessage());
+            }};
+        }
+    }
+
+    /**
+     * 导出日志（供离线分析）
+     */
+    @Operation(summary = "导出日志供离线分析")
+    @GetMapping("/logs/export")
+    public Object exportLogs() {
+        try {
+            StringBuilder sb = new StringBuilder();
+            sb.append("码流切换日志导出\n");
+            sb.append("导出时间: ").append(new Date()).append("\n");
+            sb.append("总条数: ").append(recentLogs.size()).append("\n");
+            sb.append(repeatChar('=', 60)).append("\n\n");
+
+            for (String log : recentLogs) {
+                sb.append(log).append("\n");
+            }
+
+            return new HashMap<String, Object>() {{
+                put("code", 0);
+                put("msg", "success");
+                put("data", new HashMap<String, Object>() {{
+                    put("logs", sb.toString());
+                    put("filename", String.format("stream_switch_logs_%s.txt",
+                            new java.text.SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date())));
+                }});
+            }};
+
+        } catch (Exception e) {
+            logger.error("导出日志失败", e);
+            return new HashMap<String, Object>() {{
+                put("code", -1);
+                put("msg", "导出失败: " + e.getMessage());
+            }};
+        }
+    }
+
+    /**
+     * 清除日志缓存
+     */
+    @Operation(summary = "清除日志缓存")
+    @PostMapping("/logs/clear")
+    public Object clearLogs() {
+        int count = recentLogs.size();
+        recentLogs.clear();
+
+        logger.info("已清除 {} 条日志", count);
+
+        return new HashMap<String, Object>() {{
+            put("code", 0);
+            put("msg", "已清除 " + count + " 条日志");
+        }};
+    }
+
+    /**
+     * 获取FFmpeg进程信息
+     */
+    @Operation(summary = "获取FFmpeg进程信息")
+    @GetMapping("/ffmpeg/{tag}")
+    public Object getFFmpegInfo(
+            @Parameter(description = "频道标签") @PathVariable String tag) {
+
+        try {
+            ChannelStatus status = channelStatuses.get(tag);
+            if (status == null) {
+                return new HashMap<String, Object>() {{
+                    put("code", 404);
+                    put("msg", "频道不存在: " + tag);
+                }};
+            }
+
+            return new HashMap<String, Object>() {{
+                put("code", 0);
+                put("msg", "success");
+                put("data", new HashMap<String, Object>() {{
+                    put("tag", tag);
+                    put("running", status.ffmpegRunning);
+                    put("processInfo", status.ffmpegProcessInfo);
+                    put("lastRestartTime", status.lastFFmpegRestartTime > 0
+                            ? new Date(status.lastFFmpegRestartTime).toString() : "N/A");
+                    put("restartCountToday", status.restartCountToday);
+                }});
+            }};
+
+        } catch (Exception e) {
+            logger.error("获取FFmpeg信息失败: " + tag, e);
+            return new HashMap<String, Object>() {{
+                put("code", -1);
+                put("msg", "获取失败: " + e.getMessage());
+            }};
+        }
+    }
+
+    /**
+     * 健康检查
+     */
+    @Operation(summary = "健康检查")
+    @GetMapping("/health")
+    public Object health() {
+        int errorCount = 0;
+        for (ChannelStatus status : channelStatuses.values()) {
+            if ("error".equals(status.status)) {
+                errorCount++;
+            }
+        }
+
+        final int finalErrorCount = errorCount;
+        final int totalChannels = channelStatuses.size();
+        final int logBufferSize = recentLogs.size();
+
+        return new HashMap<String, Object>() {{
+            put("code", 0);
+            put("msg", "success");
+            put("data", new HashMap<String, Object>() {{
+                put("status", finalErrorCount == 0 ? "healthy" : "degraded");
+                put("totalChannels", totalChannels);
+                put("errorChannels", finalErrorCount);
+                put("logBufferSize", logBufferSize);
+                put("timestamp", new Date());
+            }});
+        }};
+    }
+
+    /**
+     * Java 8兼容的字符重复方法
+     */
+    private static String repeatChar(char c, int count) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < count; i++) {
+            sb.append(c);
+        }
+        return sb.toString();
+    }
+}
@@ -3,15 +3,26 @@ server.http.port = 3333
 server.history.port = 9101
 server.backlog = 1024
-# ffmpegÃ¥ÂÂ¯Ã¦ÂÂ§Ã¨Â¡ÂÃ¦ÂÂÃ¤Â»Â¶Ã¨Â·Â¯Ã¥Â¾ÂÃ¯Â¼ÂÃ¥ÂÂ¯Ã¤Â»Â¥Ã§ÂÂÃ§Â©Âº
+# ffmpeg路径配置
 ffmpeg.path = ffmpeg
-# Ã©ÂÂÃ§Â½Â®rtmpÃ¥ÂÂ°Ã¥ÂÂÃ¥Â°ÂÃ¥ÂÂ¨Ã§Â»ÂÃ§Â«Â¯Ã¥ÂÂÃ©ÂÂRTPÃ¦Â¶ÂÃ¦ÂÂ¯Ã¥ÂÂÃ¦ÂÂ¶Ã¯Â¼ÂÃ©Â¢ÂÃ¥Â¤ÂÃ§ÂÂÃ¥ÂÂRTMPÃ¦ÂÂÃ¥ÂÂ¡Ã¥ÂÂ¨Ã¦ÂÂ¨Ã¦ÂµÂ
-# TAGÃ§ÂÂÃ¥Â½Â¢Ã¥Â¼ÂÃ¥Â°Â±Ã¦ÂÂ¯SIM-CHANNELÃ¯Â¼ÂÃ¥Â¦Â13800138999-2
-# Ã¥Â¦ÂÃ¦ÂÂÃ§ÂÂÃ§Â©ÂºÃ¥Â°ÂÃ¤Â¸ÂÃ¥ÂÂRTMPÃ¦ÂÂÃ¥ÂÂ¡Ã¥ÂÂ¨Ã¦ÂÂ¨Ã¦ÂµÂ
+# 推流器类型: ffmpeg | native
+# - ffmpeg: 使用FFmpeg进程推流，码流切换需要重启（1-3秒中断）
+# - native: 使用原生Java RTMP推流，码流切换无缝（0中断）
+# 默认为ffmpeg，保持向后兼容
+publisher.type = native
+
+# 原生RTMP配置（当publisher.type=native时生效）
+# ZLM的RTMP监听地址
+rtmp.native.host = 10.0.0.16
+rtmp.native.port = 1935
+rtmp.native.app = schedule
+
+# RTMP目标地址配置
+# TAG的格式通常是SIM-CHANNEL，如13800138999-2
 #rtmp.url = rtsp://192.168.169.100:9555/schedule/{TAG}?sign={sign}
 rtmp.url = rtsp://10.0.0.16:9554/schedule/{TAG}?sign={sign}
 #rtmp.url = rtsp://192.168.169.100:19555/schedule/{TAG}?sign={sign}
-# Ã¨Â®Â¾Ã§Â½Â®Ã¤Â¸ÂºonÃ¦ÂÂ¶Ã¯Â¼ÂÃ¦ÂÂ§Ã¥ÂÂ¶Ã¥ÂÂ°Ã¥Â°ÂÃ¨Â¾ÂÃ¥ÂÂºffmpegÃ§ÂÂÃ¨Â¾ÂÃ¥ÂÂº
+# 设置为on时，控制FFmpeg的输出
 debug.mode = off
 server.port = 40000
 server.http.port = 3333
-server.history.port = 30001
+server.history.port = 40001
 server.backlog = 1024
-# ffmpegå¯æ§è¡æä»¶è·¯å¾ï¼å¯ä»¥çç©º
+# ffmpeg路径配置
 ffmpeg.path = F:/ffmpeg/ffmpeg-7.0.2-essentials_build/bin/ffmpeg.exe
-# éç½®rtmpå°åå°å¨ç»ç«¯åéRTPæ¶æ¯åæ¶ï¼é¢å¤çåRTMPæå¡å¨æ¨æµ
-# TAGçå½¢å¼å°±æ¯SIM-CHANNELï¼å¦13800138999-2
-# å¦æçç©ºå°ä¸åRTMPæå¡å¨æ¨æµ
+# 推流器类型: ffmpeg | netty
+# - ffmpeg: 使用FFmpeg进程推流，码流切换需要重启（1-3秒中断）
+# - netty: 使用Netty RTMP推流（非阻塞），码流切换无缝（0中断）推荐使用
+# 默认为ffmpeg，保持向后兼容
+publisher.type = netty
+
+# 原生RTMP配置（当publisher.type=netty时生效）
+rtmp.native.host = 127.0.0.1
+rtmp.native.port = 1935
+rtmp.native.app = schedule
+
+# RTMP目标地址配置
+# TAG的格式通常是SIM-CHANNEL，如13800138999-2
 #rtmp.url = rtsp://192.168.169.100:9555/schedule/{TAG}?sign={sign}
 rtmp.url = rtsp://127.0.0.1:554/schedule/{TAG}?sign={sign}
 #rtmp.url = rtsp://192.168.169.100:19555/schedule/{TAG}?sign={sign}
-# è®¾ç½®ä¸ºonæ¶ï¼æ§å¶å°å°è¾åºffmpegçè¾åº
 debug.mode = off
 zlm.host = 127.0.0.1
@@ -99,4 +99,10 @@
 		<appender-ref ref="SipRollingFile" />
 	</logger>
+	<!-- RTMP调试日志 -->
+	<logger name="com.genersoft.iot.vmp.jtt1078.rtmp" level="debug" additivity="false">
+		<appender-ref ref="STDOUT" />
+		<appender-ref ref="RollingFile"/>
+	</logger>
+
 </configuration>
 \ No newline at end of file
+{
+  "permissions": {
+    "allow": [
+      "Bash(netstat:*)",
+      "Bash(findstr:*)",
+      "Bash(powershell -Command:*)",
+      "Bash(taskkill:*)",
+      "Bash(start python:*)",
+      "Bash(timeout:*)",
+      "Bash(tasklist:*)",
+      "Bash(start:*)"
+    ]
+  }
+}