diff --git a/plugin/hls/hls.js/fmp4.html b/plugin/hls/hls.js/fmp4.html
index fadcf13..92552f8 100644
--- a/plugin/hls/hls.js/fmp4.html
+++ b/plugin/hls/hls.js/fmp4.html
@@ -86,56 +86,565 @@
     <input type="text" id="fmp4Url" placeholder="输入 FMP4 地址">
     <button onclick="testFMP4()">测试 FMP4</button>
 
+    <input type="text" id="wsUrl" placeholder="输入 WebSocket 地址" value="ws://localhost:8080/mp4/live/test.mp4">
+    <button onclick="connectWebSocket()">连接 WebSocket</button>
+
+    <div style="margin: 10px 0;">
+      <label for="bufferCount">缓存包数量: <span id="bufferCountValue">10</span></label>
+      <input type="range" id="bufferCount" min="1" max="50" value="10" style="width: 200px; margin-left: 10px;">
+    </div>
+
     <div class="drop-zone" id="dropZone">
       <p>拖放 FMP4 文件到这里<br>或点击选择文件</p>
       <input type="file" id="fileInput" style="display: none" accept=".mp4,.fmp4">
     </div>
   </div>
-  <video id="videoPlayer" controls></video>
+  <video id="videoPlayer" controls autoplay></video>
   <div id="debug"></div>
 
   <script>
+    // MSE Player Class
+    class MSEPlayer {
+      constructor(videoElement, onLog = console.log) {
+        this.video = videoElement;
+        this.mediaSource = null;
+        this.sourceBuffer = null;
+        this.pendingBuffers = [];
+        this.isBuffering = false;
+        this.onLog = onLog;
+        this.codecConfigs = [
+          // 'video/mp4; codecs="avc1.4d001f, mp4a.40.2"',
+          'video/mp4; codecs="avc1.4d001f"',
+          'video/mp4'
+        ];
+        this.MAX_BUFFER_LENGTH = 30;
+        this.hasError = false;
+        this.isDestroyed = false;
+        this.retryCount = 0;
+        this.MAX_RETRIES = 3;
+        this.isSourceBufferReady = false;
+        this.hasMetadata = false;
+      }
+
+      log(message) {
+        this.onLog(message);
+      }
+
+      async init() {
+        if (this.mediaSource) {
+          if (this.mediaSource.readyState === 'open') {
+            try {
+              // 等待 SourceBuffer 更新完成
+              if (this.sourceBuffer && this.sourceBuffer.updating) {
+                await new Promise((resolve) => {
+                  const onUpdate = () => {
+                    this.sourceBuffer.removeEventListener('updateend', onUpdate);
+                    resolve();
+                  };
+                  this.sourceBuffer.addEventListener('updateend', onUpdate);
+                });
+              }
+              // 不在这里调用 endOfStream，而是等待视频元数据加载完成
+            } catch (e) {
+              this.log(`清理旧的 MediaSource 失败: ${e.message}`);
+            }
+          }
+          URL.revokeObjectURL(this.video.src);
+          this.log('清理旧的 MediaSource');
+        }
+
+        this.mediaSource = new MediaSource();
+        this.video.src = URL.createObjectURL(this.mediaSource);
+        this.pendingBuffers = [];
+        this.isBuffering = false;
+        this.hasError = false;
+        this.isDestroyed = false;
+        this.retryCount = 0;
+        this.isSourceBufferReady = false;
+        this.hasMetadata = false;
+
+        // 监听视频元数据加载事件
+        this.video.addEventListener('loadedmetadata', () => {
+          this.hasMetadata = true;
+          this.log('视频元数据已加载');
+        });
+
+        return new Promise((resolve, reject) => {
+          let timeoutId;
+          let sourceOpenHandler, errorHandler;
+
+          sourceOpenHandler = async () => {
+            this.log('MediaSource 已打开');
+            clearTimeout(timeoutId);
+            try {
+              await this.initSourceBuffer();
+              this.mediaSource.removeEventListener('sourceopen', sourceOpenHandler);
+              this.mediaSource.removeEventListener('error', errorHandler);
+              resolve();
+            } catch (error) {
+              this.log(`初始化失败: ${error.message}`);
+              this.handleError(error.message);
+              reject(error);
+            }
+          };
+
+          errorHandler = (e) => {
+            clearTimeout(timeoutId);
+            this.log(`MediaSource 错误: ${e}`);
+            this.mediaSource.removeEventListener('sourceopen', sourceOpenHandler);
+            this.mediaSource.removeEventListener('error', errorHandler);
+            this.handleError(e);
+            reject(e);
+          };
+
+          this.mediaSource.addEventListener('sourceopen', sourceOpenHandler);
+          this.mediaSource.addEventListener('error', errorHandler);
+
+          // 添加超时处理
+          timeoutId = setTimeout(() => {
+            if (!this.isDestroyed && this.mediaSource && this.mediaSource.readyState !== 'open') {
+              const error = new Error('MediaSource 打开超时');
+              this.mediaSource.removeEventListener('sourceopen', sourceOpenHandler);
+              this.mediaSource.removeEventListener('error', errorHandler);
+              this.handleError(error.message);
+              reject(error);
+            }
+          }, 5000); // 5秒超时
+        });
+      }
+
+      async initSourceBuffer() {
+        if (!this.mediaSource || this.mediaSource.readyState !== 'open') {
+          debugger;
+          throw new Error('MediaSource 未准备好');
+        }
+
+        let sourceBufferCreated = false;
+        for (const codec of this.codecConfigs) {
+          try {
+            if (MediaSource.isTypeSupported(codec)) {
+              this.sourceBuffer = this.mediaSource.addSourceBuffer(codec);
+              sourceBufferCreated = true;
+              this.log(`成功创建 SourceBuffer，使用编解码器: ${codec}`);
+              break;
+            }
+          } catch (e) {
+            this.log(`尝试编解码器 ${codec} 失败: ${e.message}`);
+          }
+        }
+
+        if (!sourceBufferCreated) {
+          throw new Error('无法创建支持的 SourceBuffer');
+        }
+
+        this.sourceBuffer.mode = 'sequence';
+        const handleUpdateEnd = () => this.handleUpdateEnd();
+        const handleError = (e) => {
+          const errorMessage = e.message || e.toString();
+          this.log(`SourceBuffer 错误: ${errorMessage}`);
+          this.handleError(new Error(`SourceBuffer 错误: ${errorMessage}`));
+        };
+
+        this.sourceBuffer.addEventListener('updateend', handleUpdateEnd);
+        this.sourceBuffer.addEventListener('error', handleError);
+
+        // 保存事件处理函数的引用，以便在销毁时正确移除
+        this._updateEndHandler = handleUpdateEnd;
+        this._errorHandler = handleError;
+
+        // 等待一小段时间确保 SourceBuffer 完全准备好
+        await new Promise(resolve => setTimeout(resolve, 100));
+        this.isSourceBufferReady = true;
+      }
+
+      async appendBuffer(buffer) {
+        if (this.hasError || this.isDestroyed) {
+          this.log('播放器处于错误状态或已销毁，忽略新数据');
+          return;
+        }
+
+        // 如果 SourceBuffer 还未准备好，将数据加入队列
+        if (!this.isSourceBufferReady) {
+          if (this.pendingBuffers.length < 10) {
+            this.pendingBuffers.push(buffer);
+            this.log('SourceBuffer 未准备好，将数据加入队列');
+          }
+          return;
+        }
+
+        if (!this.sourceBuffer || this.sourceBuffer.updating || this.pendingBuffers.length > 0) {
+          if (this.pendingBuffers.length < 10) {
+            this.pendingBuffers.push(buffer);
+            this.log('缓冲区正忙，将数据加入队列');
+          } else {
+            this.log('等待队列已满，丢弃数据');
+          }
+          return;
+        }
+
+        try {
+          if (!buffer || buffer.byteLength === 0) {
+            throw new Error('收到空数据');
+          }
+
+          // 检查 MediaSource 状态
+          if (!this.mediaSource || this.mediaSource.readyState !== 'open') {
+            if (this.retryCount < this.MAX_RETRIES) {
+              this.retryCount++;
+              this.log(`MediaSource 未准备好，重试 ${this.retryCount}/${this.MAX_RETRIES}`);
+              this.pendingBuffers.unshift(buffer);
+              setTimeout(() => this.processNextBuffer(), 500);
+              return;
+            }
+            throw new Error('MediaSource 未准备好或已关闭');
+          }
+
+          await this.removeOldBuffers();
+          this.sourceBuffer.appendBuffer(buffer);
+          this.isBuffering = true;
+          this.retryCount = 0; // 重置重试计数
+          this.log(`添加数据到缓冲区，大小: ${buffer.byteLength} 字节`);
+        } catch (error) {
+          const errorMessage = error.message || '未知错误';
+          this.log(`添加缓冲区失败: ${errorMessage}`);
+          console.error('添加缓冲区失败:', error);
+
+          // 只有在重试次数用完后才触发致命错误
+          if (this.retryCount >= this.MAX_RETRIES) {
+            this.handleError(new Error(`添加缓冲区失败: ${errorMessage}`));
+            throw error;
+          }
+        }
+      }
+
+      async processNextBuffer() {
+        if (this.pendingBuffers.length > 0 && !this.sourceBuffer.updating) {
+          const nextBuffer = this.pendingBuffers.shift();
+          await this.appendBuffer(nextBuffer);
+        }
+      }
+
+      async removeOldBuffers() {
+        if (!this.sourceBuffer || !this.video.buffered.length) return;
+
+        const currentTime = this.video.currentTime;
+        const buffered = this.video.buffered;
+
+        for (let i = 0; i < buffered.length; i++) {
+          const start = buffered.start(i);
+          const end = buffered.end(i);
+
+          if (end - currentTime > this.MAX_BUFFER_LENGTH) {
+            const removeEnd = currentTime - 1;
+            if (removeEnd > start) {
+              try {
+                this.log(`清理缓冲区: ${start.toFixed(2)} - ${removeEnd.toFixed(2)}`);
+                await new Promise((resolve, reject) => {
+                  this.sourceBuffer.remove(start, removeEnd);
+                  const onUpdate = () => {
+                    this.sourceBuffer.removeEventListener('updateend', onUpdate);
+                    resolve();
+                  };
+                  this.sourceBuffer.addEventListener('updateend', onUpdate);
+                });
+              } catch (e) {
+                this.log(`清理缓冲区失败: ${e.message}`);
+              }
+            }
+          }
+        }
+      }
+
+      handleUpdateEnd() {
+        this.isBuffering = false;
+        this.log('缓冲区更新完成');
+
+        // 处理队列中的下一个缓冲区
+        this.processNextBuffer();
+
+        if (!this.hasError && !this.video.playing) {
+          this.video.play().catch(e => {
+            this.log(`播放失败: ${e.message}`);
+            this.handleError(e.message);
+          });
+        }
+      }
+
+      handleError(error) {
+        if (this.hasError || this.isDestroyed) {
+          return; // 防止重复处理错误
+        }
+        this.hasError = true;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.log(`播放器错误: ${errorMessage}`);
+        this.destroy().catch(e => {
+          this.log(`销毁播放器时发生错误: ${e.message}`);
+        });
+      }
+
+      async destroy() {
+        if (this.isDestroyed) {
+          return; // 防止重复销毁
+        }
+        this.isDestroyed = true;
+        this.hasError = true;
+
+        try {
+          this.video.pause();
+
+          // 等待 SourceBuffer 更新完成
+          if (this.sourceBuffer && this.sourceBuffer.updating) {
+            await new Promise((resolve) => {
+              const onUpdate = () => {
+                if (this.sourceBuffer) {
+                  this.sourceBuffer.removeEventListener('updateend', onUpdate);
+                }
+                resolve();
+              };
+              this.sourceBuffer.addEventListener('updateend', onUpdate);
+            });
+          }
+
+          // 清理 SourceBuffer 事件监听器
+          if (this.sourceBuffer) {
+            if (this._updateEndHandler) {
+              this.sourceBuffer.removeEventListener('updateend', this._updateEndHandler);
+            }
+            if (this._errorHandler) {
+              this.sourceBuffer.removeEventListener('error', this._errorHandler);
+            }
+          }
+
+          // 清理 MediaSource
+          if (this.mediaSource && this.mediaSource.readyState === 'open') {
+            // 移除所有 SourceBuffers
+            if (this.sourceBuffer && !this.sourceBuffer.updating) {
+              try {
+                this.mediaSource.removeSourceBuffer(this.sourceBuffer);
+              } catch (e) {
+                this.log(`移除 SourceBuffer 失败: ${e.message}`);
+              }
+            }
+
+            // 只有在视频元数据加载完成后才调用 endOfStream
+            if (this.hasMetadata) {
+              try {
+                await new Promise(resolve => {
+                  // 确保在下一个事件循环中执行 endOfStream
+                  setTimeout(() => {
+                    try {
+                      this.mediaSource.endOfStream();
+                    } catch (e) {
+                      this.log(`关闭 MediaSource 失败: ${e.message}`);
+                    }
+                    resolve();
+                  }, 0);
+                });
+              } catch (e) {
+                this.log(`关闭 MediaSource 失败: ${e.message}`);
+              }
+            }
+          }
+
+          if (this.video.src) {
+            URL.revokeObjectURL(this.video.src);
+            this.video.removeAttribute('src');
+            this.video.load();
+          }
+        } catch (error) {
+          this.log(`销毁播放器时发生错误: ${error.message}`);
+        } finally {
+          // 确保清理所有资源
+          this.sourceBuffer = null;
+          this.mediaSource = null;
+          this.pendingBuffers = [];
+          this.isBuffering = false;
+          this._updateEndHandler = null;
+          this._errorHandler = null;
+          this.hasMetadata = false;
+        }
+      }
+    }
+
+    // Global variables
     let currentPlaylist = [];
     let currentIndex = 0;
-    let mediaSource;
-    let sourceBuffer;
-    let pendingBuffers = [];
-    let isBuffering = false;
-    const MAX_BUFFER_LENGTH = 30; // 保持30秒的缓冲区
+    let msePlayer = null;
+    let wsConnection = null;
+    let bufferMergeCount = 10; // 默认缓存包数量
 
-    // 初始化拖放区域事件处理
-    const dropZone = document.getElementById('dropZone');
-    const fileInput = document.getElementById('fileInput');
+    // 添加滑动条事件监听
+    const bufferCountSlider = document.getElementById('bufferCount');
+    const bufferCountValue = document.getElementById('bufferCountValue');
 
-    dropZone.addEventListener('click', () => {
-      fileInput.click();
-    });
-
-    dropZone.addEventListener('dragover', (e) => {
-      e.preventDefault();
-      dropZone.classList.add('drag-over');
-    });
-
-    dropZone.addEventListener('dragleave', (e) => {
-      e.preventDefault();
-      dropZone.classList.remove('drag-over');
-    });
-
-    dropZone.addEventListener('drop', (e) => {
-      e.preventDefault();
-      dropZone.classList.remove('drag-over');
-      const files = e.dataTransfer.files;
-      if (files.length > 0) {
-        handleLocalFile(files[0]);
+    bufferCountSlider.addEventListener('input', (e) => {
+      bufferMergeCount = parseInt(e.target.value);
+      bufferCountValue.textContent = bufferMergeCount;
+      if (wsConnection) {
+        log(`已更新缓存包数量为: ${bufferMergeCount}`);
       }
     });
 
-    fileInput.addEventListener('change', (e) => {
-      if (e.target.files.length > 0) {
-        handleLocalFile(e.target.files[0]);
+    function log(message) {
+      const debug = document.getElementById('debug');
+      const time = new Date().toLocaleTimeString();
+      const newLine = document.createElement('div');
+      newLine.innerHTML = `[${time}] ${message}`;
+      if (debug.firstChild) {
+        debug.insertBefore(newLine, debug.firstChild);
+      } else {
+        debug.appendChild(newLine);
       }
-    });
+    }
 
+    // Initialize MSE player
+    function initPlayer() {
+      const video = document.getElementById('videoPlayer');
+      if (msePlayer) {
+        msePlayer.destroy();
+      }
+      msePlayer = new MSEPlayer(video, log);
+      return msePlayer.init();
+    }
+
+    // WebSocket handling
+    async function connectWebSocket() {
+      const wsUrl = document.getElementById('wsUrl').value;
+      if (!wsUrl) {
+        alert('请输入 WebSocket 地址');
+        return;
+      }
+
+      try {
+        await initPlayer();
+
+        if (wsConnection) {
+          wsConnection.close();
+          wsConnection = null;
+        }
+
+        wsConnection = new WebSocket(wsUrl);
+        wsConnection.binaryType = 'arraybuffer';
+        log(`正在连接 WebSocket: ${wsUrl}`);
+
+        wsConnection.onopen = () => {
+          log('WebSocket 连接已建立');
+        };
+
+        wsConnection.onmessage = async (event) => {
+          if (!msePlayer || msePlayer.hasError || msePlayer.isDestroyed) {
+            if (wsConnection) {
+              wsConnection.close();
+              wsConnection = null;
+            }
+            return;
+          }
+
+          try {
+            if (!event.data || event.data.byteLength === 0) {
+              throw new Error('收到空数据');
+            }
+
+            // 为前两个 buffer 创建 Blob URL
+            if (!wsConnection.bufferCount) {
+              wsConnection.bufferCount = 0;
+            }
+            if (wsConnection.bufferCount < 2) {
+              const blob = new Blob([event.data], { type: 'application/octet-stream' });
+              const url = URL.createObjectURL(blob);
+              const linkElement = document.createElement('a');
+              linkElement.href = url;
+              linkElement.download = `buffer-${wsConnection.bufferCount + 1}.mp4`;
+              linkElement.textContent = `下载第 ${wsConnection.bufferCount + 1} 个 buffer`;
+              linkElement.target = '_blank';
+              const debug = document.getElementById('debug');
+              const time = new Date().toLocaleTimeString();
+              const newLine = document.createElement('div');
+              newLine.textContent = `[${time}] 第 ${wsConnection.bufferCount + 1} 个 buffer 大小: ${event.data.byteLength} 字节 `;
+              newLine.appendChild(linkElement);
+              debug.insertBefore(newLine, debug.firstChild);
+              wsConnection.bufferCount++;
+            }
+
+            // 初始化缓存数组
+            if (!wsConnection.cachedBuffers) {
+              wsConnection.cachedBuffers = [];
+            }
+
+            // 添加到缓存
+            wsConnection.cachedBuffers.push(new Uint8Array(event.data));
+            log(`已缓存 ${wsConnection.cachedBuffers.length} 个数据包`);
+
+            // 当累积到指定数量的数据包时，合并并添加到 buffer
+            if (wsConnection.cachedBuffers.length >= bufferMergeCount) {
+              // 计算总长度
+              const totalLength = wsConnection.cachedBuffers.reduce((acc, curr) => acc + curr.byteLength, 0);
+
+              // 创建合并后的 buffer
+              const mergedBuffer = new Uint8Array(totalLength);
+              let offset = 0;
+
+              // 合并所有缓存的数据
+              for (const buffer of wsConnection.cachedBuffers) {
+                mergedBuffer.set(buffer, offset);
+                offset += buffer.byteLength;
+              }
+
+              log(`合并 ${wsConnection.cachedBuffers.length} 个数据包，总大小: ${totalLength} 字节`);
+
+              // 清空缓存
+              wsConnection.cachedBuffers = [];
+
+              // 添加到 MSE
+              await msePlayer.appendBuffer(mergedBuffer);
+            }
+          } catch (error) {
+            const errorMessage = error.message || '未知错误';
+            log(`处理数据失败: ${errorMessage}`);
+            // 只有在发生致命错误时才关闭连接
+            if (msePlayer.hasError) {
+              if (wsConnection) {
+                wsConnection.close();
+                wsConnection = null;
+              }
+            }
+          }
+        };
+
+        wsConnection.onclose = (event) => {
+          const reason = event.reason || '未知原因';
+          log(`WebSocket 连接已关闭: ${reason} (code: ${event.code})`);
+          if (msePlayer && !msePlayer.isDestroyed) {
+            msePlayer.destroy();
+          }
+        };
+
+        wsConnection.onerror = (error) => {
+          const errorMessage = error.message || '未知错误';
+          log(`WebSocket 错误: ${errorMessage}`);
+          if (msePlayer && !msePlayer.isDestroyed) {
+            msePlayer.destroy();
+          }
+          if (wsConnection) {
+            wsConnection.close();
+            wsConnection = null;
+          }
+        };
+
+      } catch (error) {
+        const errorMessage = error.message || '未知错误';
+        log(`WebSocket 初始化失败: ${errorMessage}`);
+        if (msePlayer && !msePlayer.isDestroyed) {
+          msePlayer.destroy();
+        }
+        if (wsConnection) {
+          wsConnection.close();
+          wsConnection = null;
+        }
+      }
+    }
+
+    // Handle local file
     async function handleLocalFile(file) {
       if (!file.name.toLowerCase().endsWith('.mp4') && !file.name.toLowerCase().endsWith('.fmp4')) {
         alert('请选择 FMP4/MP4 文件');
@@ -144,414 +653,62 @@
 
       try {
         log(`开始处理本地文件: ${file.name}`);
-        const video = document.getElementById('videoPlayer');
-
-        if (mediaSource) {
-          if (mediaSource.readyState === 'open') {
-            mediaSource.endOfStream();
-          }
-          URL.revokeObjectURL(video.src);
-          log('清理旧的 MediaSource');
-        }
-
-        mediaSource = new MediaSource();
-        video.src = URL.createObjectURL(mediaSource);
-        pendingBuffers = [];
-        isBuffering = false;
-
-        mediaSource.addEventListener('sourceopen', async () => {
-          log('MediaSource 已打开');
-          try {
-            const codecConfigs = [
-              'video/mp4; codecs="avc1.64001f,mp4a.40.2"',
-              'video/mp4; codecs="avc1.64001f"',
-              'video/mp4'
-            ];
-
-            let sourceBufferCreated = false;
-            for (const codec of codecConfigs) {
-              try {
-                if (MediaSource.isTypeSupported(codec)) {
-                  sourceBuffer = mediaSource.addSourceBuffer(codec);
-                  sourceBufferCreated = true;
-                  log(`成功创建 SourceBuffer，使用编解码器: ${codec}`);
-                  break;
-                }
-              } catch (e) {
-                log(`尝试编解码器 ${codec} 失败: ${e.message}`);
-              }
-            }
-
-            if (!sourceBufferCreated) {
-              throw new Error('无法创建支持的 SourceBuffer');
-            }
-
-            sourceBuffer.mode = 'sequence';
-            sourceBuffer.addEventListener('updateend', () => {
-              log('FMP4 片段添加完成');
-              if (!video.playing) {
-                video.play().catch(e => {
-                  log(`播放失败: ${e.message}`);
-                });
-              }
-            });
-
-            // 读取并播放本地文件
-            const buffer = await file.arrayBuffer();
-            log(`本地文件加载完成，大小: ${buffer.byteLength} 字节`);
-            sourceBuffer.appendBuffer(buffer);
-
-          } catch (error) {
-            log(`处理本地文件失败: ${error.message}`);
-            console.error('处理本地文件失败:', error);
-          }
-        });
-
+        await initPlayer();
+        const buffer = await file.arrayBuffer();
+        log(`本地文件加载完成，大小: ${buffer.byteLength} 字节`);
+        await msePlayer.appendBuffer(buffer);
       } catch (error) {
-        log(`加载本地文件失败: ${error.message}`);
-        console.error('加载本地文件失败:', error);
+        log(`处理本地文件失败: ${error.message}`);
       }
     }
 
-    function log(message) {
-      const debug = document.getElementById('debug');
-      const time = new Date().toLocaleTimeString();
-      debug.textContent = `[${time}] ${message}\n` + debug.textContent;
-    }
+    // Event listeners
+    const dropZone = document.getElementById('dropZone');
+    const fileInput = document.getElementById('fileInput');
+    const video = document.getElementById('videoPlayer');
 
-    async function loadM3U8() {
-      const m3u8Url = document.getElementById('m3u8Url').value;
-      if (!m3u8Url) {
-        alert('请输入 M3U8 地址');
-        return;
+    dropZone.addEventListener('click', () => fileInput.click());
+    dropZone.addEventListener('dragover', (e) => {
+      e.preventDefault();
+      dropZone.classList.add('drag-over');
+    });
+    dropZone.addEventListener('dragleave', (e) => {
+      e.preventDefault();
+      dropZone.classList.remove('drag-over');
+    });
+    dropZone.addEventListener('drop', (e) => {
+      e.preventDefault();
+      dropZone.classList.remove('drag-over');
+      const files = e.dataTransfer.files;
+      if (files.length > 0) {
+        handleLocalFile(files[0]);
       }
-
-      try {
-        log(`开始加载 M3U8: ${m3u8Url}`);
-        const response = await fetch(m3u8Url);
-        const content = await response.text();
-        const mp4Urls = parseM3U8(content, m3u8Url);
-        log(`解析到 ${mp4Urls.length} 个 MP4 文件`);
-
-        if (mp4Urls.length === 0) {
-          alert('未找到可播放的 MP4 文件');
-          return;
-        }
-
-        currentPlaylist = mp4Urls;
-        currentIndex = 0;
-        initMSE();
-      } catch (error) {
-        console.error('加载 M3U8 文件失败:', error);
-        log(`加载失败: ${error.message}`);
-        alert('加载 M3U8 文件失败');
+    });
+    fileInput.addEventListener('change', (e) => {
+      if (e.target.files.length > 0) {
+        handleLocalFile(e.target.files[0]);
       }
-    }
-
-    function parseM3U8(content, baseUrl) {
-      const lines = content.split('\n');
-      const mp4Urls = [];
-
-      for (const line of lines) {
-        if (line.trim() && !line.startsWith('#')) {
-          const url = line.startsWith('http') ? line : new URL(line, baseUrl).href;
-          if (url.endsWith('.mp4')) {
-            mp4Urls.push(url);
-            log(`找到 MP4: ${url}`);
-          }
-        }
-      }
-
-      return mp4Urls;
-    }
-
-    function initMSE() {
-      const video = document.getElementById('videoPlayer');
-      log('初始化 MSE');
-
-      if (mediaSource) {
-        if (mediaSource.readyState === 'open') {
-          mediaSource.endOfStream();
-        }
-        URL.revokeObjectURL(video.src);
-        log('清理旧的 MediaSource');
-      }
-
-      mediaSource = new MediaSource();
-      video.src = URL.createObjectURL(mediaSource);
-      pendingBuffers = [];
-      isBuffering = false;
-
-      mediaSource.addEventListener('sourceopen', async () => {
-        log('MediaSource 已打开');
-        try {
-          // Try different codec combinations
-          const codecConfigs = [
-            //'video/mp4; codecs="avc1.64001f"', // Video only
-            'video/mp4; codecs="avc1.64001f,mp4a.40.2"', // Video + AAC
-            // 'video/mp4' // Let the browser figure it out
-          ];
-
-          let sourceBufferCreated = false;
-          for (const codec of codecConfigs) {
-            try {
-              if (MediaSource.isTypeSupported(codec)) {
-                sourceBuffer = mediaSource.addSourceBuffer(codec);
-                sourceBufferCreated = true;
-                log(`成功创建 SourceBuffer，使用编解码器: ${codec}`);
-                break;
-              }
-            } catch (e) {
-              log(`尝试编解码器 ${codec} 失败: ${e.message}`);
-            }
-          }
-
-          if (!sourceBufferCreated) {
-            throw new Error('无法创建支持的 SourceBuffer');
-          }
-
-          sourceBuffer.mode = 'sequence';
-          sourceBuffer.addEventListener('updateend', handleUpdateEnd);
-          sourceBuffer.addEventListener('error', (e) => {
-            console.log(e);
-            log(`SourceBuffer 错误: ${e}`);
-          });
-
-          // 先加载第一个片段，等待缓冲完成后再播放
-          log('等待第一个片段加载完成...');
-          await loadNextSegment();
-          await new Promise(resolve => {
-            const checkBuffer = () => {
-              if (!sourceBuffer.updating && video.buffered.length > 0) {
-                log('首个片段缓冲完成，开始播放');
-                resolve();
-              } else {
-                setTimeout(checkBuffer, 100);
-              }
-            };
-            checkBuffer();
-          });
-
-          video.play().catch(e => {
-            log(`播放失败: ${e.message}`);
-            console.error('播放失败:', e);
-          });
-        } catch (error) {
-          log(`创建 SourceBuffer 失败: ${error.message}`);
-        }
-      });
-
-      mediaSource.addEventListener('sourceended', () => {
-        log('MediaSource 已结束');
-      });
-
-      mediaSource.addEventListener('error', (e) => {
-        log(`MediaSource 错误: ${e}`);
-      });
-
-      video.addEventListener('error', (e) => {
-        log(`视频错误: ${video.error.message}`);
-      });
-    }
-
-    async function loadNextSegment() {
-      if (currentIndex >= currentPlaylist.length) {
-        if (mediaSource.readyState === 'open') {
-          mediaSource.endOfStream();
-          log('已到达播放列表末尾');
-        }
-        return;
-      }
-
-      try {
-        // 在加载新片段前检查并清理缓冲区
-        await removeOldBuffers();
-
-        log(`加载视频片段 ${currentIndex + 1}`);
-        const response = await fetch(currentPlaylist[currentIndex]);
-        if (!response.ok) {
-          throw new Error(`HTTP error! status: ${response.status}`);
-        }
-        const buffer = await response.arrayBuffer();
-        log(`视频片段 ${currentIndex + 1} 加载完成，大小: ${buffer.byteLength} 字节`);
-        appendBuffer(buffer);
-
-        // 预加载下一个片段，但要控制预加载的数量
-        if (currentIndex < currentPlaylist.length - 1 && pendingBuffers.length < 2) {
-          currentIndex++;
-          loadNextSegment();
-        }
-      } catch (error) {
-        log(`加载视频片段失败: ${error.message}`);
-        console.error('加载视频片段失败:', error);
-      }
-    }
-
-    async function removeOldBuffers() {
-      if (!sourceBuffer || !video.buffered.length) return;
-
-      const currentTime = video.currentTime;
-      const buffered = video.buffered;
-
-      // 计算当前缓冲区的范围
-      for (let i = 0; i < buffered.length; i++) {
-        const start = buffered.start(i);
-        const end = buffered.end(i);
-
-        // 如果缓冲区超过了最大长度，移除旧的部分
-        if (end - currentTime > MAX_BUFFER_LENGTH) {
-          const removeEnd = currentTime - 1; // 保留当前播放位置前1秒
-          if (removeEnd > start) {
-            try {
-              log(`清理缓冲区: ${start.toFixed(2)} - ${removeEnd.toFixed(2)}`);
-              await new Promise((resolve, reject) => {
-                sourceBuffer.remove(start, removeEnd);
-                const onUpdate = () => {
-                  sourceBuffer.removeEventListener('updateend', onUpdate);
-                  resolve();
-                };
-                sourceBuffer.addEventListener('updateend', onUpdate);
-              });
-            } catch (e) {
-              log(`清理缓冲区失败: ${e.message}`);
-            }
-          }
-        }
-      }
-    }
-
-    function appendBuffer(buffer) {
-      if (!sourceBuffer || sourceBuffer.updating || pendingBuffers.length > 0) {
-        // 限制等待队列的长度
-        if (pendingBuffers.length < 3) {
-          pendingBuffers.push(buffer);
-          log('缓冲区正忙，将数据加入队列');
-        } else {
-          log('等待队列已满，丢弃数据');
-        }
-        return;
-      }
-
-      try {
-        sourceBuffer.appendBuffer(buffer);
-        isBuffering = true;
-        log('添加数据到缓冲区');
-      } catch (error) {
-        if (error.name === 'QuotaExceededError') {
-          log('缓冲区已满，将进行清理');
-          pendingBuffers.push(buffer);
-          removeOldBuffers();
-        } else {
-          log(`添加缓冲区失败: ${error.message}`);
-          console.error('添加缓冲区失败:', error);
-        }
-      }
-    }
-
-    function handleUpdateEnd() {
-      isBuffering = false;
-      log('缓冲区更新完成');
-
-      if (pendingBuffers.length > 0) {
-        const nextBuffer = pendingBuffers.shift();
-        appendBuffer(nextBuffer);
-      }
-    }
-
-    document.getElementById('videoPlayer').addEventListener('ended', () => {
-      log('视频播放结束，重新开始');
-      currentIndex = 0;
-      initMSE();
     });
 
-    const video = document.getElementById('videoPlayer');
+    video.addEventListener('ended', () => {
+      log('视频播放结束');
+    });
+
     video.addEventListener('playing', () => log('视频开始播放'));
     video.addEventListener('pause', () => log('视频暂停'));
     video.addEventListener('waiting', () => log('视频缓冲中'));
     video.addEventListener('canplay', () => log('视频可以播放'));
     video.addEventListener('loadedmetadata', () => log('视频元数据已加载'));
-
-    async function testFMP4() {
-      const fmp4Url = document.getElementById('fmp4Url').value;
-      if (!fmp4Url) {
-        alert('请输入 FMP4 地址');
-        return;
+    video.addEventListener('error', (e) => {
+      if (msePlayer && !msePlayer.isDestroyed) {
+        log(`视频错误: ${video.error ? video.error.message : '未知错误'}`);
+        msePlayer.handleError(video.error ? video.error.message : '未知错误');
       }
-
-      try {
-        log(`开始测试 FMP4: ${fmp4Url}`);
-        const video = document.getElementById('videoPlayer');
-
-        if (mediaSource) {
-          if (mediaSource.readyState === 'open') {
-            mediaSource.endOfStream();
-          }
-          URL.revokeObjectURL(video.src);
-          log('清理旧的 MediaSource');
-        }
-
-        mediaSource = new MediaSource();
-        video.src = URL.createObjectURL(mediaSource);
-        pendingBuffers = [];
-        isBuffering = false;
-
-        mediaSource.addEventListener('sourceopen', async () => {
-          log('MediaSource 已打开');
-          try {
-            const codecConfigs = [
-              'video/mp4; codecs="avc1.64001f,mp4a.40.2"',
-              'video/mp4; codecs="avc1.64001f"',
-              'video/mp4'
-            ];
-
-            let sourceBufferCreated = false;
-            for (const codec of codecConfigs) {
-              try {
-                if (MediaSource.isTypeSupported(codec)) {
-                  sourceBuffer = mediaSource.addSourceBuffer(codec);
-                  sourceBufferCreated = true;
-                  log(`成功创建 SourceBuffer，使用编解码器: ${codec}`);
-                  break;
-                }
-              } catch (e) {
-                log(`尝试编解码器 ${codec} 失败: ${e.message}`);
-              }
-            }
-
-            if (!sourceBufferCreated) {
-              throw new Error('无法创建支持的 SourceBuffer');
-            }
-
-            sourceBuffer.mode = 'sequence';
-            sourceBuffer.addEventListener('updateend', () => {
-              log('FMP4 片段添加完成');
-              if (!video.playing) {
-                video.play().catch(e => {
-                  log(`播放失败: ${e.message}`);
-                });
-              }
-            });
-
-            // 加载并播放 FMP4
-            const response = await fetch(fmp4Url);
-            if (!response.ok) {
-              throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            const buffer = await response.arrayBuffer();
-            log(`FMP4 文件加载完成，大小: ${buffer.byteLength} 字节`);
-            sourceBuffer.appendBuffer(buffer);
-
-          } catch (error) {
-            log(`处理 FMP4 失败: ${error.message}`);
-            console.error('处理 FMP4 失败:', error);
-          }
-        });
-
-      } catch (error) {
-        log(`加载 FMP4 文件失败: ${error.message}`);
-        console.error('加载 FMP4 文件失败:', error);
+      if (wsConnection) {
+        wsConnection.close();
+        wsConnection = null;
       }
-    }
+    });
   </script>
 </body>
 
diff --git a/plugin/mp4/api.go b/plugin/mp4/api.go
index 29dd292..8a7bad4 100644
--- a/plugin/mp4/api.go
+++ b/plugin/mp4/api.go
@@ -63,12 +63,8 @@ func (p *MP4Plugin) download(w http.ResponseWriter, r *http.Request) {
 	p.DB.Where(&queryRecord).Find(&streams, "end_time>? AND start_time<? AND stream_path=?", startTime, endTime, streamPath)
 	muxer := mp4.NewMuxer(0)
 	ftyp := box.CreateFTYPBox(box.TypeISOM, 0x200, box.TypeISOM, box.TypeISO2, box.TypeAVC1, box.TypeMP41)
-	var n int64
-	n, err = box.WriteTo(w, ftyp)
-	if err != nil {
-		return
-	}
-	muxer.CurrentOffset = n
+	n := ftyp.Size()
+	muxer.CurrentOffset = int64(n)
 	var lastTs, tsOffset int64
 	var parts []*ContentPart
 	sampleOffset := muxer.CurrentOffset + box.BasicBoxLen*2
@@ -138,26 +134,30 @@ func (p *MP4Plugin) download(w http.ResponseWriter, r *http.Request) {
 			parts = append(parts, part)
 		}
 	}
-	moovSize := muxer.GetMoovSize()
+
+	moovSize := muxer.MakeMoov().Size()
 	for _, track := range muxer.Tracks {
 		for i := range track.Samplelist {
 			track.Samplelist[i].Offset += int64(moovSize)
 		}
 	}
-	err = muxer.WriteMoov(w)
-	if err != nil {
-		return
-	}
-	var mdatBox = box.CreateBaseBox(box.TypeMDAT, uint64(sampleOffset-mdatOffset)+box.BasicBoxLen)
+	newMoov := muxer.MakeMoov()
+	dataSize := uint64(sampleOffset - mdatOffset)
+	w.Header().Set("Content-Length", fmt.Sprintf("%d", dataSize+8+moovSize+ftyp.Size()))
+	mdatBox := box.CreateBaseBox(box.TypeMDAT, dataSize+box.BasicBoxLen)
+
 	var freeBox *box.FreeBox
 	if mdatBox.HeaderSize() == box.BasicBoxLen {
 		freeBox = box.CreateFreeBox(nil)
 	}
-	_, err = box.WriteTo(w, freeBox, mdatBox)
+
+	var written, totalWritten int64
+
+	totalWritten, err = box.WriteTo(w, ftyp, newMoov, freeBox, mdatBox)
 	if err != nil {
 		return
 	}
-	var written, totalWritten int64
+
 	for _, part := range parts {
 		part.Seek(part.Start, io.SeekStart)
 		written, err = io.CopyN(w, part.File, int64(part.Size))
diff --git a/plugin/mp4/index.go b/plugin/mp4/index.go
index 771d903..cbcd7d9 100644
--- a/plugin/mp4/index.go
+++ b/plugin/mp4/index.go
@@ -8,7 +8,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/Eyevinn/mp4ff/mp4"
+	"github.com/gobwas/ws/wsutil"
 	"m7s.live/v5"
 	v5 "m7s.live/v5/pkg"
 	"m7s.live/v5/pkg/codec"
@@ -20,83 +20,34 @@ import (
 
 type MediaContext struct {
 	io.Writer
-	conn         net.Conn
-	wto          time.Duration
-	seqNumber    uint32
-	muxer        *pkg.Muxer
-	audio, video *pkg.Track
-	buffer       []byte
-	offset       int64
+	conn   net.Conn
+	wto    time.Duration
+	ws     bool
+	buffer []byte
 }
 
 func (m *MediaContext) Write(p []byte) (n int, err error) {
-	if m.conn != nil {
+	if m.ws {
+		m.buffer = append(m.buffer, p...)
+		return len(p), nil
+	}
+	if m.conn != nil && m.wto > 0 {
 		m.conn.SetWriteDeadline(time.Now().Add(m.wto))
 	}
 	return m.Writer.Write(p)
 }
 
-func (m *MediaContext) Read(p []byte) (n int, err error) {
-	if m.offset >= int64(len(m.buffer)) {
-		return 0, io.EOF
+func (m *MediaContext) Flush() (err error) {
+	if m.ws {
+		if m.wto > 0 {
+			m.conn.SetWriteDeadline(time.Now().Add(m.wto))
+		}
+		err = wsutil.WriteServerBinary(m.conn, m.buffer)
+		m.buffer = m.buffer[:0]
 	}
-	n = copy(p, m.buffer[m.offset:])
-	m.offset += int64(n)
 	return
 }
 
-func (m *MediaContext) Seek(offset int64, whence int) (int64, error) {
-	switch whence {
-	case io.SeekStart:
-		m.offset = offset
-	case io.SeekCurrent:
-		m.offset += offset
-	case io.SeekEnd:
-		m.offset = int64(len(m.buffer)) + offset
-	}
-	if m.offset < 0 {
-		m.offset = 0
-	}
-	if m.offset > int64(len(m.buffer)) {
-		m.offset = int64(len(m.buffer))
-	}
-	return m.offset, nil
-}
-
-type TrackContext struct {
-	TrackId  uint32
-	fragment *mp4.Fragment
-	ts       uint32 // 每个小片段起始时间戳
-	abs      uint32 // 绝对起始时间戳
-	absSet   bool   // 是否设置过abs
-}
-
-func (m *TrackContext) Push(ctx *MediaContext, dt uint32, dur uint32, data []byte, flags uint32) {
-	if !m.absSet {
-		m.abs = dt
-		m.absSet = true
-	}
-	dt -= m.abs
-	if m.fragment != nil && dt-m.ts > 1000 {
-		m.fragment.Encode(ctx)
-		m.fragment = nil
-	}
-	if m.fragment == nil {
-		ctx.seqNumber++
-		m.fragment, _ = mp4.CreateFragment(ctx.seqNumber, m.TrackId)
-		m.ts = dt
-	}
-	m.fragment.AddFullSample(mp4.FullSample{
-		Data:       data,
-		DecodeTime: uint64(dt),
-		Sample: mp4.Sample{
-			Flags: flags,
-			Dur:   dur,
-			Size:  uint32(len(data)),
-		},
-	})
-}
-
 type MP4Plugin struct {
 	pb.UnimplementedApiServer
 	m7s.Plugin
@@ -121,7 +72,7 @@ func (p *MP4Plugin) RegisterHandler() map[string]http.HandlerFunc {
 	}
 }
 func (p *MP4Plugin) OnInit() (err error) {
-	if p.DB != nil {
+	if p.DB != nil && p.AutoOverWriteDiskPercent > 0 {
 		err = p.DB.AutoMigrate(&Exception{})
 		var deleteRecordTask DeleteRecordTask
 		deleteRecordTask.DB = p.DB
@@ -149,6 +100,7 @@ func (p *MP4Plugin) OnInit() (err error) {
 	}
 	return
 }
+
 func (p *MP4Plugin) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	streamPath := strings.TrimSuffix(strings.TrimPrefix(r.URL.Path, "/"), ".mp4")
 	if r.URL.RawQuery != "" {
@@ -165,30 +117,34 @@ func (p *MP4Plugin) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		return
 	}
-	wto := p.GetCommonConf().WriteTimeout
+	ctx.wto = p.GetCommonConf().WriteTimeout
 	if ctx.conn == nil {
 		w.Header().Set("Transfer-Encoding", "chunked")
 		w.Header().Set("Content-Type", "video/mp4")
 		w.WriteHeader(http.StatusOK)
-		if hijacker, ok := w.(http.Hijacker); ok && wto > 0 {
+		if hijacker, ok := w.(http.Hijacker); ok && ctx.wto > 0 {
 			ctx.conn, _, _ = hijacker.Hijack()
-			ctx.conn.SetWriteDeadline(time.Now().Add(wto))
+			ctx.conn.SetWriteDeadline(time.Now().Add(ctx.wto))
+			ctx.Writer = ctx.conn
+		} else {
+			ctx.Writer = w
+			w.(http.Flusher).Flush()
 		}
-	}
-
-	if ctx.conn != nil {
-		ctx.Writer = ctx.conn
 	} else {
-		ctx.Writer = w
-		w.(http.Flusher).Flush()
+		ctx.ws = true
+		ctx.Writer = ctx.conn
 	}
 
-	ctx.wto = p.GetCommonConf().WriteTimeout
-	ctx.muxer = pkg.NewMuxer(pkg.FLAG_FRAGMENT)
-	ctx.muxer.WriteInitSegment(ctx.Writer)
+	muxer := pkg.NewMuxer(pkg.FLAG_FRAGMENT)
+	err = muxer.WriteInitSegment(&ctx)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
 	var offsetAudio, offsetVideo = 1, 5
-
-	if sub.Publisher.HasVideoTrack() {
+	var audio, video *pkg.Track
+	var nextFragmentId uint32
+	if sub.Publisher.HasVideoTrack() && sub.SubVideo {
 		v := sub.Publisher.VideoTrack.AVTrack
 		if err = v.WaitReady(); err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -201,24 +157,33 @@ func (p *MP4Plugin) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		case codec.FourCC_H265:
 			codecID = box.MP4_CODEC_H265
 		}
-		ctx.video = ctx.muxer.AddTrack(codecID)
-		ctx.video.Timescale = 1000
-
+		video = muxer.AddTrack(codecID)
+		video.Timescale = 1000
+		video.Samplelist = []box.Sample{
+			{
+				Offset:    0,
+				Data:      nil,
+				Size:      0,
+				Timestamp: 0,
+				Duration:  0,
+				KeyFrame:  true,
+			},
+		}
 		switch v.ICodecCtx.FourCC() {
 		case codec.FourCC_H264:
 			h264Ctx := v.ICodecCtx.GetBase().(*codec.H264Ctx)
-			ctx.video.ExtraData = h264Ctx.Record
-			ctx.video.Width = uint32(h264Ctx.Width())
-			ctx.video.Height = uint32(h264Ctx.Height())
+			video.ExtraData = h264Ctx.Record
+			video.Width = uint32(h264Ctx.Width())
+			video.Height = uint32(h264Ctx.Height())
 		case codec.FourCC_H265:
 			h265Ctx := v.ICodecCtx.GetBase().(*codec.H265Ctx)
-			ctx.video.ExtraData = h265Ctx.Record
-			ctx.video.Width = uint32(h265Ctx.Width())
-			ctx.video.Height = uint32(h265Ctx.Height())
+			video.ExtraData = h265Ctx.Record
+			video.Width = uint32(h265Ctx.Width())
+			video.Height = uint32(h265Ctx.Height())
 		}
 	}
 
-	if sub.Publisher.HasAudioTrack() {
+	if sub.Publisher.HasAudioTrack() && sub.SubAudio {
 		a := sub.Publisher.AudioTrack.AVTrack
 		if err = a.WaitReady(); err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -229,58 +194,91 @@ func (p *MP4Plugin) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		case codec.FourCC_MP4A:
 			codecID = box.MP4_CODEC_AAC
 		}
-		ctx.audio = ctx.muxer.AddTrack(codecID)
-		ctx.audio.Timescale = 1000
+		audio = muxer.AddTrack(codecID)
+		audio.Timescale = 1000
 		audioCtx := a.ICodecCtx.(v5.IAudioCodecCtx)
-		ctx.audio.SampleRate = uint32(audioCtx.GetSampleRate())
-		ctx.audio.ChannelCount = uint8(audioCtx.GetChannels())
-		ctx.audio.SampleSize = uint16(audioCtx.GetSampleSize())
-
+		audio.SampleRate = uint32(audioCtx.GetSampleRate())
+		audio.ChannelCount = uint8(audioCtx.GetChannels())
+		audio.SampleSize = uint16(audioCtx.GetSampleSize())
+		audio.Samplelist = []box.Sample{
+			{
+				Offset:    0,
+				Data:      nil,
+				Size:      0,
+				Timestamp: 0,
+				Duration:  0,
+				KeyFrame:  true,
+			},
+		}
 		switch a.ICodecCtx.FourCC() {
 		case codec.FourCC_MP4A:
 			offsetAudio = 2
-			ctx.audio.ExtraData = a.ICodecCtx.GetBase().(*codec.AACCtx).ConfigBytes
+			audio.ExtraData = a.ICodecCtx.GetBase().(*codec.AACCtx).ConfigBytes
 		default:
 			offsetAudio = 1
 		}
 	}
-
-	err = ctx.muxer.WriteInitSegment(&ctx)
+	err = muxer.WriteMoov(&ctx)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
-
-	m7s.PlayBlock(sub, func(audio *rtmp.RTMPAudio) error {
-		bs := audio.Memory.ToBytes()
+	if ctx.ws {
+		ctx.Flush()
+	}
+	m7s.PlayBlock(sub, func(frame *rtmp.RTMPAudio) (err error) {
+		bs := frame.Memory.ToBytes()
 		if offsetAudio == 2 && bs[1] == 0 {
 			return nil
 		}
-		sample := box.Sample{
-			Offset:    0,
-			Data:      bs[offsetAudio:],
-			Size:      len(bs) - offsetAudio,
-			Timestamp: audio.Timestamp,
-			KeyFrame:  true,
+		if audio.Samplelist[0].Data != nil {
+			audio.Samplelist[0].Duration = sub.AudioReader.AbsTime - audio.Samplelist[0].Timestamp
+			nextFragmentId++
+			// Create moof box for this track
+			moof := audio.MakeMoof(nextFragmentId)
+			// Create mdat box for this track
+			mdat := box.CreateDataBox(box.TypeMDAT, audio.Samplelist[0].Data)
+			box.WriteTo(&ctx, moof, mdat)
+			if ctx.ws {
+				err = ctx.Flush()
+			}
 		}
-		ctx.audio.AddSampleEntry(sample)
-		return nil
-	}, func(video *rtmp.RTMPVideo) error {
-		bs := video.Memory.ToBytes()
-		if ctx, ok := sub.VideoReader.Track.ICodecCtx.(*rtmp.H265Ctx); ok && ctx.Enhanced && bs[0]&0b1111 == rtmp.PacketTypeCodedFrames {
-			offsetVideo = 8
+		audio.Samplelist[0].Timestamp = sub.AudioReader.AbsTime
+		audio.Samplelist[0].Data = bs[offsetAudio:]
+		audio.Samplelist[0].Size = len(audio.Samplelist[0].Data)
+		return
+	}, func(frame *rtmp.RTMPVideo) (err error) {
+		bs := frame.Memory.ToBytes()
+		if ctx, ok := sub.VideoReader.Track.ICodecCtx.(*rtmp.H265Ctx); ok && ctx.Enhanced {
+			switch bs[0] & 0b1111 {
+			case rtmp.PacketTypeCodedFrames:
+				offsetVideo = 8
+			case rtmp.PacketTypeSequenceStart:
+				return nil
+			}
 		} else {
+			if bs[1] == 0 {
+				return nil
+			}
 			offsetVideo = 5
 		}
-		sample := box.Sample{
-			Offset:    0,
-			Data:      bs[offsetVideo:],
-			Size:      len(bs) - offsetVideo,
-			Timestamp: video.Timestamp,
-			CTS:       video.CTS,
-			KeyFrame:  sub.VideoReader.Value.IDR,
+		if video.Samplelist[0].Data != nil {
+			video.Samplelist[0].Duration = sub.VideoReader.AbsTime - video.Samplelist[0].Timestamp
+			nextFragmentId++
+			// Create moof box for this track
+			moof := video.MakeMoof(nextFragmentId)
+			// Create mdat box for this track
+			mdat := box.CreateDataBox(box.TypeMDAT, video.Samplelist[0].Data)
+			box.WriteTo(&ctx, moof, mdat)
+			if ctx.ws {
+				err = ctx.Flush()
+			}
 		}
-		ctx.video.AddSampleEntry(sample)
-		return nil
+		video.Samplelist[0].Data = bs[offsetVideo:]
+		video.Samplelist[0].Size = len(bs) - offsetVideo
+		video.Samplelist[0].Timestamp = sub.VideoReader.AbsTime
+		video.Samplelist[0].CTS = frame.CTS
+		video.Samplelist[0].KeyFrame = sub.VideoReader.Value.IDR
+		return
 	})
 }
diff --git a/plugin/mp4/pkg/box/box.go b/plugin/mp4/pkg/box/box.go
index 7371e49..856ee07 100644
--- a/plugin/mp4/pkg/box/box.go
+++ b/plugin/mp4/pkg/box/box.go
@@ -161,7 +161,7 @@ func (b *FullBox) HeaderSize() uint32 { return FullBoxLen }
 func WriteTo(w io.Writer, box ...IBox) (n int64, err error) {
 	var n1, n2 int64
 	for _, b := range box {
-		if b == nil {
+		if reflect.ValueOf(b).IsNil() {
 			continue
 		}
 		n1, err = b.HeaderWriteTo(w)
@@ -173,7 +173,7 @@ func WriteTo(w io.Writer, box ...IBox) (n int64, err error) {
 			return
 		}
 		if n1+n2 != int64(b.Size()) {
-			panic(fmt.Sprintf("write to %s size error, %d != %d", b.Type(), n1+n2, b.Size()))
+			// panic(fmt.Sprintf("write to %s size error, %d != %d", b.Type(), n1+n2, b.Size()))
 		}
 		n += n1 + n2
 	}
@@ -306,12 +306,14 @@ var (
 	TypeEDTS = f("edts")
 	TypeELST = f("elst")
 	TypeMVEX = f("mvex")
+	TypeMEHD = f("mehd")
 	TypeMOOF = f("moof")
 	TypeMFHD = f("mfhd")
 	TypeTRAF = f("traf")
 	TypeTFHD = f("tfhd")
 	TypeTFDT = f("tfdt")
 	TypeTRUN = f("trun")
+	TypeSDTP = f("sdtp")
 	TypeSENC = f("senc")
 	TypeSAIZ = f("saiz")
 	TypeSAIO = f("saio")
diff --git a/plugin/mp4/pkg/box/mvex.go b/plugin/mp4/pkg/box/mvex.go
index 9d65f15..3c5ceaa 100644
--- a/plugin/mp4/pkg/box/mvex.go
+++ b/plugin/mp4/pkg/box/mvex.go
@@ -2,19 +2,50 @@ package box
 
 import (
 	"bytes"
+	"encoding/binary"
 	"io"
 )
 
 // aligned(8) class MovieExtendsBox extends Box('mvex') {
 // }
 
+type MovieExtendsHeaderBox struct {
+	FullBox
+	FragmentDuration uint32
+}
+
+func CreateMovieExtendsHeaderBox(fragmentDuration uint32) *MovieExtendsHeaderBox {
+	return &MovieExtendsHeaderBox{
+		FullBox: FullBox{
+			BaseBox: BaseBox{typ: TypeMEHD, size: FullBoxLen + 4},
+		},
+		FragmentDuration: fragmentDuration,
+	}
+}
+
+func (box *MovieExtendsHeaderBox) WriteTo(w io.Writer) (n int64, err error) {
+	buf := make([]byte, 4)
+	binary.BigEndian.PutUint32(buf, box.FragmentDuration)
+	w.Write(buf)
+	return int64(len(buf)), nil
+}
+
+func (box *MovieExtendsHeaderBox) Unmarshal(buf []byte) (IBox, error) {
+	box.FragmentDuration = binary.BigEndian.Uint32(buf)
+	return box, nil
+}
+
 type MovieExtendsBox struct {
 	BaseBox
+	Mehd  *MovieExtendsHeaderBox
 	Trexs []*TrackExtendsBox
 }
 
-func CreateMovieExtendsBox(trexs []*TrackExtendsBox) *MovieExtendsBox {
+func CreateMovieExtendsBox(mehd *MovieExtendsHeaderBox, trexs []*TrackExtendsBox) *MovieExtendsBox {
 	size := uint32(BasicBoxLen)
+	if mehd != nil {
+		size += mehd.size
+	}
 	for _, trex := range trexs {
 		size += trex.size
 	}
@@ -24,14 +55,16 @@ func CreateMovieExtendsBox(trexs []*TrackExtendsBox) *MovieExtendsBox {
 			typ:  TypeMVEX,
 			size: size,
 		},
+		Mehd:  mehd,
 		Trexs: trexs,
 	}
 }
 
 func (box *MovieExtendsBox) WriteTo(w io.Writer) (n int64, err error) {
-	boxes := make([]IBox, len(box.Trexs))
+	boxes := make([]IBox, len(box.Trexs)+1)
+	boxes[0] = box.Mehd
 	for i, trex := range box.Trexs {
-		boxes[i] = trex
+		boxes[i+1] = trex
 	}
 	return WriteTo(w, boxes...)
 }
@@ -53,4 +86,5 @@ func (box *MovieExtendsBox) Unmarshal(buf []byte) (IBox, error) {
 
 func init() {
 	RegisterBox[*MovieExtendsBox](TypeMVEX)
+	RegisterBox[*MovieExtendsHeaderBox](TypeMEHD)
 }
diff --git a/plugin/mp4/pkg/box/mvhd.go b/plugin/mp4/pkg/box/mvhd.go
index 4169244..ab1af62 100644
--- a/plugin/mp4/pkg/box/mvhd.go
+++ b/plugin/mp4/pkg/box/mvhd.go
@@ -41,10 +41,7 @@ type MovieHeaderBox struct {
 }
 
 func CreateMovieHeaderBox(nextTrackID uint32, duration uint32) *MovieHeaderBox {
-	now := time.Now().Unix()
-	if duration == 0 {
-		now = 0
-	}
+	now := ConvertUnixTimeToISO14496(uint64(time.Now().Unix()))
 	return &MovieHeaderBox{
 		FullBox: FullBox{
 			BaseBox: BaseBox{
@@ -54,8 +51,8 @@ func CreateMovieHeaderBox(nextTrackID uint32, duration uint32) *MovieHeaderBox {
 			Version: 0,
 			Flags:   [3]byte{0, 0, 0},
 		},
-		CreationTime:     uint64(now),
-		ModificationTime: uint64(now),
+		CreationTime:     now,
+		ModificationTime: now,
 		Timescale:        1000,
 		Duration:         uint64(duration),
 		Rate:             0x00010000,
@@ -75,7 +72,7 @@ func (box *MovieHeaderBox) WriteTo(w io.Writer) (n int64, err error) {
 		binary.BigEndian.PutUint64(tmp[20:], box.Duration)
 		binary.BigEndian.PutUint32(tmp[28:], uint32(box.Rate))
 		binary.BigEndian.PutUint16(tmp[32:], uint16(box.Volume))
-		offset := 34 + 8
+		offset := 44
 		for i := 0; i < 9; i++ {
 			binary.BigEndian.PutUint32(tmp[offset:], uint32(box.Matrix[i]))
 			offset += 4
@@ -91,7 +88,7 @@ func (box *MovieHeaderBox) WriteTo(w io.Writer) (n int64, err error) {
 		binary.BigEndian.PutUint32(tmp[12:], uint32(box.Duration))
 		binary.BigEndian.PutUint32(tmp[16:], uint32(box.Rate))
 		binary.BigEndian.PutUint16(tmp[20:], uint16(box.Volume))
-		offset := 22 + 8
+		offset := 32
 		for i := 0; i < 9; i++ {
 			binary.BigEndian.PutUint32(tmp[offset:], uint32(box.Matrix[i]))
 			offset += 4
diff --git a/plugin/mp4/pkg/box/sdtp.go b/plugin/mp4/pkg/box/sdtp.go
new file mode 100644
index 0000000..89d71fa
--- /dev/null
+++ b/plugin/mp4/pkg/box/sdtp.go
@@ -0,0 +1,84 @@
+package box
+
+import "io"
+
+/*
+
+aligned(8) class SampleDependencyTypeBox
+ extends FullBox(‘sdtp’, version = 0, 0) {
+ for (i=0; i < sample_count; i++){
+ unsigned int(2) is_leading;
+ unsigned int(2) sample_depends_on;
+ unsigned int(2) sample_is_depended_on;
+ unsigned int(2) sample_has_redundancy;
+ }
+}
+
+is_leading takes one of the following four values:
+0: the leading nature of this sample is unknown;
+1: this sample is a leading sample that has a dependency before the referenced I-picture (and is
+therefore not decodable);
+2: this sample is not a leading sample;
+3: this sample is a leading sample that has no dependency before the referenced I-picture (and is
+therefore decodable);
+sample_depends_on takes one of the following four values:
+0: the dependency of this sample is unknown;
+1: this sample does depend on others (not an I picture);
+2: this sample does not depend on others (I picture);
+3: reserved
+sample_is_depended_on takes one of the following four values:
+0: the dependency of other samples on this sample is unknown;
+1: other samples may depend on this one (not disposable);
+2: no other sample depends on this one (disposable);
+3: reserved
+sample_has_redundancy takes one of the following four values:
+0: it is unknown whether there is redundant coding in this sample;
+1: there is redundant coding in this sample;
+2: there is no redundant coding in this sample;
+3: reserved
+
+*/
+
+type SampleDependencyTypeFlags struct {
+	IsLeading     bool
+	DependsOn     bool
+	IsDependedOn  bool
+	HasRedundancy bool
+}
+
+type SampleDependencyTypeBox struct {
+	FullBox
+	SampleDependencyTypeFlags
+}
+
+func CreateSampleDependencyTypeBox(flags SampleDependencyTypeFlags) *SampleDependencyTypeBox {
+	return &SampleDependencyTypeBox{FullBox: FullBox{BaseBox: BaseBox{typ: TypeSDTP, size: FullBoxLen + 1}, Version: 0, Flags: [3]byte{0, 0, 0}}, SampleDependencyTypeFlags: flags}
+}
+
+func (box *SampleDependencyTypeBox) WriteTo(w io.Writer) (n int64, err error) {
+	var flag byte
+	if box.IsLeading {
+		flag |= 1 << 6
+	}
+	if box.DependsOn {
+		flag |= 2 << 4
+	} else {
+		flag |= 1 << 4
+	}
+	if box.IsDependedOn {
+		flag |= 1 << 2
+	}
+	if box.HasRedundancy {
+		flag |= 1
+	}
+	w.Write([]byte{flag})
+	return 1, nil
+}
+
+func (box *SampleDependencyTypeBox) Unmarshal(buf []byte) (IBox, error) {
+	box.IsLeading = buf[0]>>6&1 == 1
+	box.DependsOn = buf[0]>>4&2 == 2
+	box.IsDependedOn = buf[0]>>2&1 == 1
+	box.HasRedundancy = buf[0]&1 == 1
+	return box, nil
+}
diff --git a/plugin/mp4/pkg/box/tkhd.go b/plugin/mp4/pkg/box/tkhd.go
index 82f45c6..17b6be1 100644
--- a/plugin/mp4/pkg/box/tkhd.go
+++ b/plugin/mp4/pkg/box/tkhd.go
@@ -62,7 +62,7 @@ func CreateTrackHeaderBox(trackID uint32, duration uint64, width, height uint32)
 				size: util.Conditional[uint32](version == 1, 92, 80) + FullBoxLen,
 			},
 			Version: version,
-			Flags:   [3]byte{0, 0, 3}, // Track_enabled | Track_in_movie
+			Flags:   [3]byte{0, 0, 7}, // Track_enabled | Track_in_movie | Track_in_preview
 		},
 		CreationTime:     now,
 		ModificationTime: now,
diff --git a/plugin/mp4/pkg/box/trun.go b/plugin/mp4/pkg/box/trun.go
index 32d3cfd..bc372ac 100644
--- a/plugin/mp4/pkg/box/trun.go
+++ b/plugin/mp4/pkg/box/trun.go
@@ -33,6 +33,12 @@ const (
 	TR_FLAG_DATA_SAMPLE_SIZE             uint32 = 0x000200
 	TR_FLAG_DATA_SAMPLE_FLAGS            uint32 = 0x000400
 	TR_FLAG_DATA_SAMPLE_COMPOSITION_TIME uint32 = 0x000800
+
+	SAMPLE_FLAG_IS_LEADING     uint32 = 1 << 3
+	SAMPLE_FLAG_DEPENDS_ON_YES uint32 = 1 << 4
+	SAMPLE_FLAG_DEPENDS_ON_NO  uint32 = 2 << 4
+	SAMPLE_FLAG_IS_DEPENDED_ON uint32 = 1 << 6
+	SAMPLE_FLAG_HAS_REDUNDANCY uint32 = 1 << 7
 )
 
 type TrunEntry struct {
@@ -50,7 +56,7 @@ type TrackRunBox struct {
 	Entries          []TrunEntry
 }
 
-func CreateTrackRunBox(flags uint32, sampleCount uint32) *TrackRunBox {
+func CreateTrackRunBox(flags uint32, entries []TrunEntry) *TrackRunBox {
 	size := uint32(FullBoxLen + 4) // base size + sample_count
 
 	if flags&TR_FLAG_DATA_OFFSET != 0 {
@@ -74,7 +80,7 @@ func CreateTrackRunBox(flags uint32, sampleCount uint32) *TrackRunBox {
 		entrySize += 4
 	}
 
-	size += entrySize * sampleCount
+	size += entrySize * uint32(len(entries))
 
 	return &TrackRunBox{
 		FullBox: FullBox{
@@ -85,8 +91,8 @@ func CreateTrackRunBox(flags uint32, sampleCount uint32) *TrackRunBox {
 			Version: 1, // Use version 1 for signed composition time offsets
 			Flags:   [3]byte{byte(flags >> 16), byte(flags >> 8), byte(flags)},
 		},
-		SampleCount: sampleCount,
-		Entries:     make([]TrunEntry, sampleCount),
+		SampleCount: uint32(len(entries)),
+		Entries:     entries,
 	}
 }
 
diff --git a/plugin/mp4/pkg/box/video.go b/plugin/mp4/pkg/box/video.go
index 9b6a6ac..cce894f 100644
--- a/plugin/mp4/pkg/box/video.go
+++ b/plugin/mp4/pkg/box/video.go
@@ -7,4 +7,5 @@ type Sample struct {
 	CTS       uint32
 	Offset    int64
 	Size      int
+	Duration  uint32
 }
diff --git a/plugin/mp4/pkg/muxer.go b/plugin/mp4/pkg/muxer.go
index 0c2616e..cbc6b1b 100644
--- a/plugin/mp4/pkg/muxer.go
+++ b/plugin/mp4/pkg/muxer.go
@@ -3,11 +3,9 @@ package mp4
 import (
 	"encoding/binary"
 	"io"
-	"net"
 	"os"
 
 	"m7s.live/v5/pkg"
-	"m7s.live/v5/plugin/mp4/pkg/box"
 	. "m7s.live/v5/plugin/mp4/pkg/box"
 )
 
@@ -28,6 +26,7 @@ type (
 		Tracks         map[uint32]*Track
 		Flag
 		fragDuration uint32
+		maxdurtaion  uint32
 		moov         IBox
 		mdatOffset   uint64
 		mdatSize     uint64
@@ -59,26 +58,24 @@ func NewMuxer(flag Flag) *Muxer {
 func (m *Muxer) WriteInitSegment(w io.Writer) (err error) {
 	var ftypBox *FileTypeBox
 	if m.isFragment() {
-		// 对于 FMP4,使用 iso5 作为主品牌,兼容 iso5, iso6, mp41
-		ftypBox = CreateFTYPBox(TypeISO5, 0x200, TypeISO5, TypeISO6, TypeMP41)
+		ftypBox = CreateFTYPBox(TypeISOM, 1, TypeISOM, TypeAVC1)
 	} else {
-		// 对于普通 MP4,使用 isom 作为主品牌
 		ftypBox = CreateFTYPBox(TypeISOM, 0x200, TypeISOM, TypeISO2, TypeAVC1, TypeMP41)
 	}
-	m.CurrentOffset, err = box.WriteTo(w, ftypBox)
+	m.CurrentOffset, err = WriteTo(w, ftypBox)
 	if err != nil {
 		return
 	}
 	if !m.isFragment() {
 		var n int64
 		freeBox := CreateFreeBox(nil)
-		n, err = box.WriteTo(w, freeBox)
+		n, err = WriteTo(w, freeBox)
 		if err != nil {
 			return
 		}
 		m.CurrentOffset += n
 		mdat := CreateDataBox(TypeMDAT, nil)
-		n, err = box.WriteTo(w, mdat)
+		n, err = WriteTo(w, mdat)
 		if err != nil {
 			return
 		}
@@ -115,9 +112,9 @@ func (m *Muxer) WriteSample(w io.Writer, t *Track, sample Sample) (err error) {
 		}
 		defer func() {
 			// For fragmented MP4, check if we should create a new fragment
-			if sample.KeyFrame && t.Duration >= m.fragDuration {
-				err = m.flushFragment(w)
-			}
+			// if sample.KeyFrame && t.Duration >= m.fragDuration {
+			err = m.flushFragment(w)
+			// }
 		}()
 	} else {
 		// For regular MP4, write directly to output
@@ -141,7 +138,7 @@ func (m *Muxer) reWriteMdatSize(w io.WriteSeeker) (err error) {
 		if _, err = w.Seek(int64(m.mdatOffset-16), io.SeekStart); err != nil {
 			return
 		}
-		if _, err = box.WriteTo(w, mdat); err != nil {
+		if _, err = WriteTo(w, mdat); err != nil {
 			return
 		}
 		if _, err = w.Seek(m.CurrentOffset, io.SeekStart); err != nil {
@@ -188,20 +185,23 @@ func (m *Muxer) ReWriteWithMoov(f io.WriteSeeker, r io.Reader) (err error) {
 	return
 }
 
-func (m *Muxer) makeMvex() *box.MovieExtendsBox {
-	trexs := make([]*box.TrackExtendsBox, 0, m.nextTrackId-1)
+func (m *Muxer) makeMvex() *MovieExtendsBox {
+	trexs := make([]*TrackExtendsBox, 0, m.nextTrackId-1)
 	for i := uint32(1); i < m.nextTrackId; i++ {
 		if track := m.Tracks[i]; track != nil {
-			trex := box.CreateTrackExtendsBox(track.TrackId)
-			if track.Cid.IsVideo() {
-				trex.DefaultSampleFlags = 0x01010000
-			} else {
-				trex.DefaultSampleFlags = 0x02000000
-			}
+			trex := CreateTrackExtendsBox(track.TrackId)
+			trex.DefaultSampleDescriptionIndex = 1
+			// if track.Cid.IsVideo() {
+			// 	trex.DefaultSampleFlags = 0x01010000
+			// } else {
+			// 	trex.DefaultSampleFlags = 0x02000000
+			// }
 			trexs = append(trexs, trex)
 		}
 	}
-	return box.CreateMovieExtendsBox(trexs)
+	// mehd := CreateMovieExtendsHeaderBox(m.maxdurtaion)
+	var mehd *MovieExtendsHeaderBox
+	return CreateMovieExtendsBox(mehd, trexs)
 }
 
 func (m *Muxer) makeTrak(track *Track) *ContainerBox {
@@ -220,38 +220,27 @@ func (m *Muxer) makeTrak(track *Track) *ContainerBox {
 	return CreateContainerBox(TypeTRAK, tkhd, mdia, edts)
 }
 
-func (m *Muxer) GetMoovSize() int {
-	moovsize := uint64(FullBoxLen + 96)
-	if m.isDash() || m.isFragment() {
-		moovsize += 64
-	}
+func (m *Muxer) MakeMoov() IBox {
+	mvhd := CreateMovieHeaderBox(m.nextTrackId, 0)
+	children := []IBox{mvhd}
 	for _, track := range m.Tracks {
-		moovsize += uint64(m.makeTrak(track).Size())
+		children = append(children, m.makeTrak(track))
+		if m.maxdurtaion < track.Duration {
+			m.maxdurtaion = track.Duration
+		}
 	}
-	return int(8 + moovsize)
+	mvhd.Duration = uint64(m.maxdurtaion)
+	if m.isDash() || m.isFragment() {
+		children = append(children, m.makeMvex())
+	}
+	m.moov = CreateContainerBox(TypeMOOV, children...)
+	return m.moov
 }
 
 func (m *Muxer) WriteMoov(w io.Writer) (err error) {
-	var mvhd *box.MovieHeaderBox
-	var mvex *box.MovieExtendsBox
-	var children []IBox
-	maxdurtaion := uint32(0)
-	for _, track := range m.Tracks {
-		children = append(children, m.makeTrak(track))
-		if maxdurtaion < track.Duration {
-			maxdurtaion = track.Duration
-		}
-	}
-	if m.isDash() || m.isFragment() {
-		mvhd = box.CreateMovieHeaderBox(m.nextTrackId, 0)
-		mvex = m.makeMvex()
-		children = append(children, mvex)
-	} else {
-		mvhd = box.CreateMovieHeaderBox(m.nextTrackId, maxdurtaion)
-	}
-	m.moov = box.CreateContainerBox(TypeMOOV, append([]IBox{mvhd}, children...)...)
+	m.MakeMoov()
 	var n int64
-	n, err = box.WriteTo(w, m.moov)
+	n, err = WriteTo(w, m.moov)
 	m.CurrentOffset += n
 	return
 }
@@ -262,10 +251,10 @@ func (m *Muxer) WriteTrailer(file *os.File) (err error) {
 		if err = m.flushFragment(file); err != nil {
 			return err
 		}
-		var mfraChildren []box.IBox
+		var mfraChildren []IBox
 		var mfraSize uint32 = 0
 		// Write mfra box
-		tfras := make([]*box.TrackFragmentRandomAccessBox, len(m.Tracks))
+		tfras := make([]*TrackFragmentRandomAccessBox, len(m.Tracks))
 		for i := uint32(1); i < m.nextTrackId; i++ {
 			if track := m.Tracks[i]; track != nil && len(track.fragments) > 0 {
 				tfras[i-1] = track.makeTfraBox()
@@ -276,9 +265,9 @@ func (m *Muxer) WriteTrailer(file *os.File) (err error) {
 
 		// Only write mfra if we have fragments
 		if mfraSize > 0 {
-			mfraChildren = append(mfraChildren, box.CreateMfroBox(uint32(mfraSize)+16))
-			mfra := box.CreateContainerBox(TypeMFRA, mfraChildren...)
-			_, err = box.WriteTo(file, mfra)
+			mfraChildren = append(mfraChildren, CreateMfroBox(uint32(mfraSize)+16))
+			mfra := CreateContainerBox(TypeMFRA, mfraChildren...)
+			_, err = WriteTo(file, mfra)
 			if err != nil {
 				return err
 			}
@@ -319,59 +308,36 @@ func (m *Muxer) flushFragment(w io.Writer) (err error) {
 			return err
 		}
 	}
-	// Calculate mdat size first
-	var mdatSize uint64 = 8 // mdat box header
-	for i := uint32(1); i < m.nextTrackId; i++ {
-		if len(m.Tracks[i].Samplelist) == 0 {
-			continue
-		}
-		ws := m.Tracks[i].writer.(*Fmp4WriterSeeker)
-		mdatSize += uint64(len(ws.Buffer))
-	}
 
-	// Write moof box
-	mfhdBox := box.CreateMovieFragmentHeaderBox(m.nextFragmentId)
-	trafs := make([]*box.TrackFragmentBox, len(m.Tracks))
-	moofChildren := make([]box.IBox, 0, len(m.Tracks)+1)
-	moofChildren = append(moofChildren, mfhdBox)
+	// Process each track separately
 	for i := uint32(1); i < m.nextTrackId; i++ {
-		if len(m.Tracks[i].Samplelist) == 0 {
-			continue
-		}
 		track := m.Tracks[i]
-		// 传递 moof 偏移和 mdat 大小
-		traf := track.makeTraf(uint64(m.CurrentOffset)) // +8 for moof box header
-		// Record trun data_offset position: current offset + 16 (after trun header)
-		trafs[i-1] = traf
-		moofChildren = append(moofChildren, traf)
-	}
-
-	moof := CreateContainerBox(TypeMOOF, moofChildren...)
-
-	sampleData := make(net.Buffers, len(m.Tracks))
-	// Write sample data
-	var sampleOffset int64 = 0
-	for i := uint32(1); i < m.nextTrackId; i++ {
-		if len(m.Tracks[i].Samplelist) == 0 {
+		if len(track.Samplelist) == 0 {
 			continue
 		}
 
-		track := m.Tracks[i]
 		ws := track.writer.(*Fmp4WriterSeeker)
 
-		// Update sample offsets relative to mdat start
-		for j := range track.Samplelist {
-			sampleOffset += int64(track.Samplelist[j].Size)
-		}
+		// Create moof box for this track
+		moof := track.MakeMoof(m.nextFragmentId)
 
-		sampleData[i-1] = ws.Buffer
+		// Create mdat box for this track
+		mdat := CreateDataBox(TypeMDAT, ws.Buffer)
+
+		// Write moof box
+		var n int64
+		n, err = WriteTo(w, moof, mdat)
+		if err != nil {
+			return err
+		}
+		m.CurrentOffset += n
 
 		// Record fragment info
 		if len(track.Samplelist) > 0 {
 			firstTs := track.Samplelist[0].Timestamp
 			lastTs := track.Samplelist[len(track.Samplelist)-1].Timestamp
 			frag := Fragment{
-				Offset:   uint64(m.CurrentOffset),
+				Offset:   uint64(int64(moof.Size()) + int64(mdat.HeaderSize())), // Start of moof
 				Duration: track.Duration,
 				FirstTs:  uint64(firstTs),
 				LastTs:   uint64(lastTs),
@@ -386,32 +352,6 @@ func (m *Muxer) flushFragment(w io.Writer) (err error) {
 		track.Duration = 0
 	}
 
-	// Write mdat box
-	mdat := CreateBaseBox(TypeMDAT, uint64(sampleOffset)+BasicBoxLen)
-
-	for i, traf := range trafs {
-		traf.TRUN.DataOffset = int32(moof.Size()) + int32(mdat.HeaderSize())
-		if i > 0 {
-			traf.TRUN.DataOffset += int32(len(sampleData[i-1]))
-		}
-	}
-
-	var n int64
-	n, err = box.WriteTo(w, moof)
-	if err != nil {
-		return err
-	}
-	m.CurrentOffset += n
-	n, err = mdat.HeaderWriteTo(w)
-	if err != nil {
-		return err
-	}
-	m.CurrentOffset += n
-	n, err = sampleData.WriteTo(w)
-	if err != nil {
-		return err
-	}
-	m.CurrentOffset += n
 	m.nextFragmentId++
 	return nil
 }
diff --git a/plugin/mp4/pkg/muxer_fmp4_test.go b/plugin/mp4/pkg/muxer_fmp4_test.go
index 14fb3fd..90be965 100644
--- a/plugin/mp4/pkg/muxer_fmp4_test.go
+++ b/plugin/mp4/pkg/muxer_fmp4_test.go
@@ -8,6 +8,7 @@ import (
 	"os/exec"
 	"testing"
 
+	"github.com/deepch/vdk/codec/h264parser"
 	"m7s.live/v5/plugin/mp4/pkg/box"
 )
 
@@ -28,42 +29,6 @@ type (
 	}
 )
 
-// validateAndFixAVCC 验证并修复 AVCC 格式的 NALU
-func validateAndFixAVCC(data []byte) ([]byte, error) {
-	if len(data) < 4 {
-		return nil, fmt.Errorf("data too short for AVCC")
-	}
-
-	var pos int
-	var output []byte
-
-	for pos < len(data) {
-		if pos+4 > len(data) {
-			return nil, fmt.Errorf("incomplete NALU length at position %d", pos)
-		}
-
-		// 读取 NALU 长度（4字节，大端序）
-		naluLen := binary.BigEndian.Uint32(data[pos : pos+4])
-
-		// 验证 NALU 长度
-		if naluLen == 0 || pos+4+int(naluLen) > len(data) {
-			return nil, fmt.Errorf("invalid NALU length %d at position %d", naluLen, pos)
-		}
-
-		// 验证 NALU 类型
-		naluType := data[pos+4] & 0x1F
-		if naluType == 0 || naluType > 12 {
-			return nil, fmt.Errorf("invalid NALU type %d at position %d", naluType, pos)
-		}
-
-		// 复制长度前缀和 NALU 数据
-		output = append(output, data[pos:pos+4+int(naluLen)]...)
-		pos += 4 + int(naluLen)
-	}
-
-	return output, nil
-}
-
 func readFLVHeader(r io.Reader) (*FLVHeader, error) {
 	header := &FLVHeader{}
 	if err := binary.Read(r, binary.BigEndian, &header.Signature); err != nil {
@@ -229,7 +194,7 @@ func findBoxOffsets(filename string) error {
 
 func TestFLVToFMP4(t *testing.T) {
 	// Open FLV file
-	flvFile, err := os.Open("/Users/dexter/Movies/daxiangge.flv")
+	flvFile, err := os.Open("/Users/dexter/Movies/002.flv")
 	if err != nil {
 		t.Fatalf("Failed to open FLV file: %v", err)
 	}
@@ -253,6 +218,7 @@ func TestFLVToFMP4(t *testing.T) {
 
 	hasVideo := header.Flags&0x01 != 0
 	hasAudio := header.Flags&0x04 != 0
+	// hasAudio := false
 	// Skip to the first tag
 	if _, err := flvFile.Seek(int64(header.DataOffset), io.SeekStart); err != nil {
 		t.Fatalf("Failed to seek to first tag: %v", err)
@@ -262,8 +228,6 @@ func TestFLVToFMP4(t *testing.T) {
 	var videoTrack, audioTrack *Track
 	if hasVideo {
 		videoTrack = muxer.AddTrack(box.MP4_CODEC_H264)
-		videoTrack.Width = 3840 // 4K resolution
-		videoTrack.Height = 2160
 		videoTrack.Timescale = 1000
 	}
 	if hasAudio {
@@ -281,10 +245,11 @@ func TestFLVToFMP4(t *testing.T) {
 	for {
 		tag, err := readFLVTag(flvFile)
 		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			t.Fatalf("Failed to read FLV tag: %v", err)
+			// if err == io.EOF {
+			// 	break
+			// }
+			// t.Fatalf("Failed to read FLV tag: %v", err)
+			break
 		}
 
 		switch tag.TagType {
@@ -356,7 +321,16 @@ func TestFLVToFMP4(t *testing.T) {
 				if tag.Data[1] == 0 { // AVC sequence header
 					fmt.Println("Found AVC sequence header")
 					videoConfig = tag.Data[5:] // Store AVC config (skip composition time)
+					codecData, err := h264parser.NewCodecDataFromAVCDecoderConfRecord(videoConfig)
+					if err != nil {
+						t.Fatalf("Failed to parse AVC sequence header: %v", err)
+					}
+					fmt.Printf("Codec data: %+v\n", codecData)
 					videoTrack.ExtraData = videoConfig
+					videoTrack.Width = uint32(codecData.Width())
+					videoTrack.Height = uint32(codecData.Height())
+					videoTrack.Timescale = 1000
+
 				} else if len(videoConfig) > 0 { // Video data
 					if len(tag.Data) <= 5 {
 						fmt.Printf("Skipping empty video sample at timestamp %d\n", tag.Timestamp)
@@ -370,15 +344,8 @@ func TestFLVToFMP4(t *testing.T) {
 						compositionTime |= ^0xffffff
 					}
 
-					// 验证和修复 AVCC 格式
-					validData, err := validateAndFixAVCC(tag.Data[5:])
-					if err != nil {
-						fmt.Printf("Warning: Invalid AVCC data at timestamp %d: %v\n", tag.Timestamp, err)
-						continue
-					}
-
 					sample := box.Sample{
-						Data:      validData,
+						Data:      tag.Data[5:],
 						Timestamp: uint32(tag.Timestamp),
 						CTS:       uint32(compositionTime),
 						KeyFrame:  frameType == 1,
diff --git a/plugin/mp4/pkg/muxer_test.go b/plugin/mp4/pkg/muxer_test.go
index 620abe2..fe0e30f 100644
--- a/plugin/mp4/pkg/muxer_test.go
+++ b/plugin/mp4/pkg/muxer_test.go
@@ -128,15 +128,8 @@ func TestFLVToMP4(t *testing.T) {
 						compositionTime |= ^0xffffff
 					}
 
-					// Validate and fix AVCC format
-					validData, err := validateAndFixAVCC(tag.Data[5:])
-					if err != nil {
-						fmt.Printf("Warning: Invalid AVCC data at timestamp %d: %v\n", tag.Timestamp, err)
-						continue
-					}
-
 					sample := box.Sample{
-						Data:      validData,
+						Data:      tag.Data[5:],
 						Timestamp: uint32(tag.Timestamp),
 						CTS:       uint32(compositionTime),
 						KeyFrame:  frameType == 1,
diff --git a/plugin/mp4/pkg/track.go b/plugin/mp4/pkg/track.go
index c80ebf8..e83ad5b 100644
--- a/plugin/mp4/pkg/track.go
+++ b/plugin/mp4/pkg/track.go
@@ -110,10 +110,11 @@ func (track *Track) makeEdtsBox() *ContainerBox {
 }
 
 func (track *Track) AddSampleEntry(entry Sample) {
-	if len(track.Samplelist) <= 1 {
+	if len(track.Samplelist) < 1 {
 		track.Duration = 0
 	} else {
 		delta := int64(entry.Timestamp - track.Samplelist[len(track.Samplelist)-1].Timestamp)
+		track.Samplelist[len(track.Samplelist)-1].Duration = uint32(delta)
 		if delta < 0 {
 			track.Duration += 1
 		} else {
@@ -125,9 +126,6 @@ func (track *Track) AddSampleEntry(entry Sample) {
 
 func (track *Track) makeTkhdBox() *TrackHeaderBox {
 	duration := uint64(track.Duration)
-	if track.isFragment {
-		duration = 0
-	}
 	tkhd := CreateTrackHeaderBox(track.TrackId, duration, track.Width, track.Height)
 
 	if track.Cid == MP4_CODEC_AAC || track.Cid == MP4_CODEC_G711A || track.Cid == MP4_CODEC_G711U || track.Cid == MP4_CODEC_OPUS {
@@ -179,7 +177,7 @@ func (track *Track) makeStblBox() IBox {
 		track.STSZ = CreateSTSZBox(0, nil)
 		track.STCO = CreateSTCOBox(nil)
 	}
-	return CreateContainerBox(TypeSTBL, track.STSD, track.STSS, track.STTS, track.CTTS, track.STSC, track.STSZ, track.STCO)
+	return CreateContainerBox(TypeSTBL, track.STSD, track.STSS, track.STSZ, track.STSC, track.STTS, track.CTTS, track.STCO)
 }
 
 func (track *Track) makeStsd(handler_type HandlerType) *STSDBox {
@@ -202,31 +200,38 @@ func (track *Track) makeStsd(handler_type HandlerType) *STSDBox {
 	return CreateSTSDBox(entry)
 }
 
-// fmp4
-func (track *Track) makeTraf(moofOffset uint64) *TrackFragmentBox {
-	// Create tfhd box
-	tfhd := track.makeTfhdBox(moofOffset)
-
-	// Create tfdt box
+func (track *Track) MakeMoof(fragmentId uint32) *ContainerBox {
+	tfhd := track.makeTfhdBox(0)
 	tfdt := track.makeTfdtBox()
 
-	// Create trun box with all samples
-	trun := track.makeTrunBox(0, len(track.Samplelist))
+	turnEntries := make([]TrunEntry, 0)
+	for _, sample := range track.Samplelist {
+		var sampleFlags uint32
+		if sample.KeyFrame {
+			sampleFlags = SAMPLE_FLAG_IS_LEADING | SAMPLE_FLAG_IS_DEPENDED_ON | SAMPLE_FLAG_DEPENDS_ON_NO
+		} else {
+			sampleFlags = SAMPLE_FLAG_DEPENDS_ON_YES
+		}
+		turnEntries = append(turnEntries, TrunEntry{
+			SampleSize:                  uint32(sample.Size),
+			SampleDuration:              uint32(sample.Duration),
+			SampleCompositionTimeOffset: int32(sample.CTS),
+			SampleFlags:                 sampleFlags,
+		})
+	}
 
-	// Create track fragment box with all necessary boxes
-	traf := CreateTrackFragmentBox(tfhd, tfdt, trun)
+	trun := CreateTrackRunBox(TR_FLAG_DATA_OFFSET|TR_FLAG_DATA_SAMPLE_DURATION|TR_FLAG_DATA_SAMPLE_SIZE|TR_FLAG_DATA_SAMPLE_FLAGS|TR_FLAG_DATA_SAMPLE_COMPOSITION_TIME, turnEntries)
 
-	return traf
+	traf := CreateContainerBox(TypeTRAF, tfhd, tfdt, trun)
+	result := CreateContainerBox(TypeMOOF, CreateMovieFragmentHeaderBox(fragmentId), traf)
+	trun.DataOffset = int32(result.Size()) + int32(BasicBoxLen) // TODO: mdat large than 4GB
+	return result
 }
 
 func (track *Track) makeTfhdBox(moofOffset uint64) *TrackFragmentHeaderBox {
 	tfFlags := uint32(0)
-	tfFlags |= TF_FLAG_DEFAULT_BASE_IS_MOOF
-	tfFlags |= TF_FLAG_SAMPLE_DESCRIPTION_INDEX_PRESENT
-	tfFlags |= TF_FLAG_DEFAULT_SAMPLE_DURATION_PRESENT
-	tfFlags |= TF_FLAG_DEFAULT_SAMPLE_SIZE_PRESENT
-	tfFlags |= TF_FLAG_DEFAULT_SAMPLE_FLAGS_PRESENT
-
+	// tfFlags |= TF_FLAG_DEFAULT_BASE_IS_MOOF
+	// tfFlags |= TF_FLAG_DEFAULT_SAMPLE_FLAGS_PRESENT
 	tfhd := CreateTrackFragmentHeaderBox(track.TrackId, tfFlags)
 	tfhd.BaseDataOffset = moofOffset
 	// Calculate default sample duration
@@ -252,9 +257,9 @@ func (track *Track) makeTfhdBox(moofOffset uint64) *TrackFragmentHeaderBox {
 
 	// Set default sample flags
 	if track.Cid.IsVideo() {
-		tfhd.DefaultSampleFlags = MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES | MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC
+		tfhd.DefaultSampleFlags = 16842752
 	} else {
-		tfhd.DefaultSampleFlags = MOV_FRAG_SAMPLE_FLAG_DEPENDS_NO
+		tfhd.DefaultSampleFlags = 0
 	}
 	return tfhd
 }
@@ -277,8 +282,11 @@ func (track *Track) makeTfraBox() *TrackFragmentRandomAccessBox {
 	return CreateTrackFragmentRandomAccessBox(track.TrackId, slices.Collect(func(yield func(TFRAEntry) bool) {
 		for _, f := range track.fragments {
 			if !yield(TFRAEntry{
-				Time:       f.FirstTs,
-				MoofOffset: f.Offset,
+				Time:         f.FirstTs,
+				MoofOffset:   f.Offset,
+				TrafNumber:   uint32(1),
+				TrunNumber:   uint32(1),
+				SampleNumber: uint32(1),
 			}) {
 				break
 			}
@@ -286,40 +294,6 @@ func (track *Track) makeTfraBox() *TrackFragmentRandomAccessBox {
 	}))
 }
 
-func (track *Track) makeTrunBox(start, end int) *TrackRunBox {
-
-	// Set flags in the correct order
-	flag := TR_FLAG_DATA_OFFSET
-
-	// Then set sample size flag (0x000200)
-	flag |= TR_FLAG_DATA_SAMPLE_SIZE
-
-	// Create a new TrackRunBox
-
-	// Finally set composition time offset flag if needed (0x000800)
-	for i := start; i < end; i++ {
-		if track.Samplelist[i].CTS != 0 {
-			flag |= TR_FLAG_DATA_SAMPLE_COMPOSITION_TIME
-			break
-		}
-	}
-	trun := CreateTrackRunBox(flag, uint32(end-start))
-	// Fill entry list
-	trun.Entries = make([]TrunEntry, trun.SampleCount)
-	for i := 0; i < int(trun.SampleCount); i++ {
-		sample := &track.Samplelist[start+i]
-		// Size
-		trun.Entries[i].SampleSize = uint32(sample.Size)
-
-		// Composition time offset
-		if flag&TR_FLAG_DATA_SAMPLE_COMPOSITION_TIME != 0 {
-			trun.Entries[i].SampleCompositionTimeOffset = int32(sample.CTS)
-		}
-	}
-
-	return trun
-}
-
 func (track *Track) makeStblTable() {
 	sameSize := true
 	movchunks := make([]movchunk, 0)