..

AV/AV.pri

@@ -17,7 +17,7 @@ HEADERS += \
     $$PWD/code/utils/utils_frame_queue.h \
     $$PWD/code/utils/utils_packet_queue.h \
     $$PWD/code/utils/utils_performance_monitor.h \
-    $$PWD/code/utils/utils_synchronizer.h \
+    $$PWD/code/utils/utils_synchronizer_v2.h \
     $$PWD/code/utils/utils_thread_pool.h
 
 SOURCES += \
@@ -38,18 +38,27 @@ SOURCES += \
     $$PWD/code/utils/utils_frame_queue.cpp \
     $$PWD/code/utils/utils_packet_queue.cpp \
     $$PWD/code/utils/utils_performance_monitor.cpp \
-    $$PWD/code/utils/utils_synchronizer.cpp \
+    $$PWD/code/utils/utils_synchronizer_v2.cpp \
     $$PWD/code/utils/utils_thread_pool.cpp
 
 include($$PWD/code/player/player.pri)
 
+# Test files (uncomment to enable)
 # SOURCES += $$PWD/test_basic.cpp
 # SOURCES += $$PWD/test_codec.cpp
 # SOURCES += $$PWD/test_decoder.cpp
 # SOURCES += $$PWD/test_audio_encoder.cpp
 # SOURCES += $$PWD/test_window_capture.cpp
 # SOURCES += $$PWD/test_utils.cpp
+SOURCES += $$PWD/test_audio_debug.cpp
 
+# Example files for PlayerV2 (uncomment to enable)
+# SOURCES += $$PWD/code/examples/player_v2_example.cpp
+
+# PlayerV2 Test Configuration (uncomment to enable full test suite)
+# include($$PWD/test_playerv2.pri)
+
+# Legacy integration example
 # SOURCES += $$PWD/integration_example.cpp
 
 

AV/code/base/types.h

@@ -117,6 +117,9 @@ enum class ErrorCode {
     THREAD_ERROR,
     QUEUE_FULL,
     
+    // 同步错误
+    SYNC_ERROR,
+    
     // 通用错误
     ALREADY_EXISTS,
     NOT_FOUND,
@@ -143,7 +146,9 @@ using ErrorCallback = std::function<void(ErrorCode, const std::string&)>;
 // 自定义删除器用于AVFrame
 struct AVFrameDeleter {
     void operator()(AVFrame* frame) {
-        av_frame_free(&frame);
+        if (frame) {
+            av_frame_free(&frame);
+        }
     }
 };
 using AVFramePtr = std::unique_ptr<AVFrame, AVFrameDeleter>;
@@ -222,4 +227,4 @@ namespace video {
 
 } // namespace av
 
-#endif // AV_BASE_TYPES_H
+#endif // AV_BASE_TYPES_H

AV/code/codec/codec_audio_decoder.cpp

@@ -297,11 +297,16 @@ ErrorCode AudioDecoder::setupDecoderParams() {
 ErrorCode AudioDecoder::decodeFrame(const AVPacketPtr& packet, std::vector<AVFramePtr>& frames) {
     // 发送包到解码器
     int ret = avcodec_send_packet(codecCtx_.get(), packet ? packet.get() : nullptr);
-    if (ret < 0 && ret != AVERROR_EOF) {
+    if (ret < 0 && ret != AVERROR_EOF && ret != AVERROR(EAGAIN)) {
         AV_LOGGER_ERRORF("发送包到音频解码器失败: {}", ffmpeg_utils::errorToString(ret));
         return static_cast<ErrorCode>(ret);
     }
     
+    // AVERROR(EAGAIN) 表示解码器暂时无法接受更多输入，这是正常情况
+    if (ret == AVERROR(EAGAIN)) {
+        AV_LOGGER_DEBUGF("解码器暂时无法接受更多输入 (EAGAIN)，继续接收帧");
+    }
+    
     // 接收解码后的帧
     return receiveFrames(frames);
 }

AV/code/examples/player_v2_example.cpp

@@ -0,0 +1,321 @@
+#include "../player/player_core_v2.h"
+#include "../base/logger.h"
+#include <iostream>
+#include <thread>
+#include <chrono>
+#include <string>
+
+using namespace av::player;
+using namespace av::utils;
+
+// 示例事件回调类
+class ExamplePlayerCallback : public PlayerEventCallback {
+public:
+    void onStateChanged(PlayerState newState) override {
+        std::string stateStr;
+        switch (newState) {
+            case PlayerState::Idle: stateStr = "Idle"; break;
+            case PlayerState::Opening: stateStr = "Opening"; break;
+            case PlayerState::Stopped: stateStr = "Stopped"; break;
+            case PlayerState::Playing: stateStr = "Playing"; break;
+            case PlayerState::Paused: stateStr = "Paused"; break;
+            case PlayerState::Seeking: stateStr = "Seeking"; break;
+            case PlayerState::Error: stateStr = "Error"; break;
+        }
+        std::cout << "[EVENT] State changed to: " << stateStr << std::endl;
+    }
+    
+    void onPositionChanged(int64_t position) override {
+        // 每秒更新一次位置信息
+        static auto lastUpdate = std::chrono::steady_clock::now();
+        auto now = std::chrono::steady_clock::now();
+        if (std::chrono::duration_cast<std::chrono::seconds>(now - lastUpdate).count() >= 1) {
+            double seconds = position / 1000000.0;
+            std::cout << "[EVENT] Position: " << std::fixed << std::setprecision(2) << seconds << "s" << std::endl;
+            lastUpdate = now;
+        }
+    }
+    
+    void onMediaInfoChanged(const MediaInfo& info) override {
+        std::cout << "[EVENT] Media info changed:" << std::endl;
+        std::cout << "  File: " << info.filename << std::endl;
+        std::cout << "  Duration: " << (info.duration / 1000000.0) << "s" << std::endl;
+        std::cout << "  Has Video: " << (info.hasVideo ? "Yes" : "No") << std::endl;
+        std::cout << "  Has Audio: " << (info.hasAudio ? "Yes" : "No") << std::endl;
+        
+        if (info.hasVideo) {
+            std::cout << "  Video: " << info.width << "x" << info.height << " @ " << info.fps << " fps" << std::endl;
+        }
+        
+        if (info.hasAudio) {
+            std::cout << "  Audio: " << info.sampleRate << " Hz, " << info.channels << " channels" << std::endl;
+        }
+    }
+    
+    void onErrorOccurred(const std::string& error) override {
+        std::cout << "[ERROR] " << error << std::endl;
+    }
+    
+    void onFrameDropped(int64_t totalDropped) override {
+        std::cout << "[WARNING] Frame dropped, total: " << totalDropped << std::endl;
+    }
+    
+    void onSyncError(double error, const std::string& reason) override {
+        std::cout << "[WARNING] Sync error: " << (error * 1000) << "ms, reason: " << reason << std::endl;
+    }
+};
+
+// 简单的命令行界面
+class SimplePlayerUI {
+public:
+    SimplePlayerUI(PlayerCoreV2* player) : m_player(player), m_running(true) {}
+    
+    void run() {
+        std::cout << "\n=== PlayerCoreV2 Example ===" << std::endl;
+        std::cout << "Commands:" << std::endl;
+        std::cout << "  open <filename>  - Open media file" << std::endl;
+        std::cout << "  play             - Start playback" << std::endl;
+        std::cout << "  pause            - Pause playback" << std::endl;
+        std::cout << "  stop             - Stop playback" << std::endl;
+        std::cout << "  seek <seconds>   - Seek to position" << std::endl;
+        std::cout << "  speed <rate>     - Set playback speed (0.5-4.0)" << std::endl;
+        std::cout << "  volume <level>   - Set volume (0.0-1.0)" << std::endl;
+        std::cout << "  stats            - Show playback statistics" << std::endl;
+        std::cout << "  debug            - Show debug information" << std::endl;
+        std::cout << "  config           - Show sync configuration" << std::endl;
+        std::cout << "  quit             - Exit program" << std::endl;
+        std::cout << "============================\n" << std::endl;
+        
+        std::string line;
+        while (m_running && std::getline(std::cin, line)) {
+            processCommand(line);
+        }
+    }
+    
+private:
+    void processCommand(const std::string& line) {
+        std::istringstream iss(line);
+        std::string command;
+        iss >> command;
+        
+        if (command == "open") {
+            std::string filename;
+            iss >> filename;
+            if (!filename.empty()) {
+                auto result = m_player->openFile(filename);
+                if (result == ErrorCode::SUCCESS) {
+                    std::cout << "File opened successfully" << std::endl;
+                } else {
+                    std::cout << "Failed to open file: " << static_cast<int>(result) << std::endl;
+                }
+            } else {
+                std::cout << "Usage: open <filename>" << std::endl;
+            }
+        }
+        else if (command == "play") {
+            auto result = m_player->play();
+            if (result == ErrorCode::SUCCESS) {
+                std::cout << "Playback started" << std::endl;
+            } else {
+                std::cout << "Failed to start playback: " << static_cast<int>(result) << std::endl;
+            }
+        }
+        else if (command == "pause") {
+            auto result = m_player->pause();
+            if (result == ErrorCode::SUCCESS) {
+                std::cout << "Playback paused" << std::endl;
+            } else {
+                std::cout << "Failed to pause playback: " << static_cast<int>(result) << std::endl;
+            }
+        }
+        else if (command == "stop") {
+            auto result = m_player->stop();
+            if (result == ErrorCode::SUCCESS) {
+                std::cout << "Playback stopped" << std::endl;
+            } else {
+                std::cout << "Failed to stop playback: " << static_cast<int>(result) << std::endl;
+            }
+        }
+        else if (command == "seek") {
+            double seconds;
+            iss >> seconds;
+            if (iss) {
+                int64_t timestamp = static_cast<int64_t>(seconds * 1000000); // 转换为微秒
+                auto result = m_player->seek(timestamp);
+                if (result == ErrorCode::SUCCESS) {
+                    std::cout << "Seeking to " << seconds << "s" << std::endl;
+                } else {
+                    std::cout << "Failed to seek: " << static_cast<int>(result) << std::endl;
+                }
+            } else {
+                std::cout << "Usage: seek <seconds>" << std::endl;
+            }
+        }
+        else if (command == "speed") {
+            double speed;
+            iss >> speed;
+            if (iss) {
+                auto result = m_player->setPlaybackSpeed(speed);
+                if (result == ErrorCode::SUCCESS) {
+                    std::cout << "Playback speed set to " << speed << "x" << std::endl;
+                } else {
+                    std::cout << "Failed to set playback speed: " << static_cast<int>(result) << std::endl;
+                }
+            } else {
+                std::cout << "Usage: speed <rate>" << std::endl;
+            }
+        }
+        else if (command == "volume") {
+            double volume;
+            iss >> volume;
+            if (iss) {
+                m_player->setVolume(volume);
+                std::cout << "Volume set to " << volume << std::endl;
+            } else {
+                std::cout << "Usage: volume <level>" << std::endl;
+            }
+        }
+        else if (command == "stats") {
+            showStats();
+        }
+        else if (command == "debug") {
+            std::cout << m_player->getDebugInfo() << std::endl;
+        }
+        else if (command == "config") {
+            showSyncConfig();
+        }
+        else if (command == "quit" || command == "exit") {
+            m_running = false;
+            std::cout << "Exiting..." << std::endl;
+        }
+        else if (!command.empty()) {
+            std::cout << "Unknown command: " << command << std::endl;
+        }
+    }
+    
+    void showStats() {
+        auto stats = m_player->getStats();
+        
+        std::cout << "\n=== Playback Statistics ===" << std::endl;
+        std::cout << "Current Time: " << std::fixed << std::setprecision(2) << (stats.currentTime / 1000000.0) << "s" << std::endl;
+        std::cout << "Playback Speed: " << stats.playbackSpeed << "x" << std::endl;
+        std::cout << "Total Frames: " << stats.totalFrames << std::endl;
+        std::cout << "Dropped Frames: " << stats.droppedFrames << std::endl;
+        std::cout << "Duplicated Frames: " << stats.duplicatedFrames << std::endl;
+        std::cout << "Sync Error: " << std::fixed << std::setprecision(1) << (stats.syncError * 1000) << "ms" << std::endl;
+        std::cout << "Avg Sync Error: " << std::fixed << std::setprecision(1) << (stats.avgSyncError * 1000) << "ms" << std::endl;
+        std::cout << "Max Sync Error: " << std::fixed << std::setprecision(1) << (stats.maxSyncError * 1000) << "ms" << std::endl;
+        std::cout << "CPU Usage: " << std::fixed << std::setprecision(1) << stats.cpuUsage << "%" << std::endl;
+        std::cout << "Memory Usage: " << std::fixed << std::setprecision(1) << stats.memoryUsage << "MB" << std::endl;
+        std::cout << "Queued Packets: " << stats.queuedPackets << std::endl;
+        std::cout << "Queued Video Frames: " << stats.queuedVideoFrames << std::endl;
+        std::cout << "Queued Audio Frames: " << stats.queuedAudioFrames << std::endl;
+        std::cout << "Bitrate: " << std::fixed << std::setprecision(1) << stats.bitrate << " kbps" << std::endl;
+        std::cout << "===========================\n" << std::endl;
+    }
+    
+    void showSyncConfig() {
+        auto config = m_player->getSyncConfig();
+        
+        std::cout << "\n=== Sync Configuration ===" << std::endl;
+        std::cout << "Sync Strategy: " << static_cast<int>(config.syncStrategy) << std::endl;
+        std::cout << "Audio Sync Threshold: " << (config.audioSyncThreshold * 1000) << "ms" << std::endl;
+        std::cout << "Video Sync Threshold: " << (config.videoSyncThreshold * 1000) << "ms" << std::endl;
+        std::cout << "Max Sync Error: " << (config.maxSyncError * 1000) << "ms" << std::endl;
+        std::cout << "Clock Update Interval: " << config.clockUpdateInterval << "ms" << std::endl;
+        std::cout << "Smoothing Window: " << config.smoothingWindow << std::endl;
+        std::cout << "Adaptive Sync: " << (config.enableAdaptiveSync ? "Enabled" : "Disabled") << std::endl;
+        std::cout << "Frame Drop: " << (config.enableFrameDrop ? "Enabled" : "Disabled") << std::endl;
+        std::cout << "Frame Duplicate: " << (config.enableFrameDuplicate ? "Enabled" : "Disabled") << std::endl;
+        std::cout << "Prediction: " << (config.enablePrediction ? "Enabled" : "Disabled") << std::endl;
+        std::cout << "==========================\n" << std::endl;
+    }
+    
+    PlayerCoreV2* m_player;
+    bool m_running;
+};
+
+int main(int argc, char* argv[]) {
+    // 初始化日志系统
+    Logger::instance().setLevel(LogLevel::INFO);
+    Logger::instance().info("PlayerCoreV2 Example Started");
+    
+    try {
+        // 创建同步配置
+        SyncConfigV2 syncConfig;
+        syncConfig.syncStrategy = SyncStrategy::ADAPTIVE;  // 使用自适应同步策略
+        syncConfig.audioSyncThreshold = 0.040;  // 40ms
+        syncConfig.videoSyncThreshold = 0.020;  // 20ms
+        syncConfig.maxSyncError = 0.200;        // 200ms
+        syncConfig.clockUpdateInterval = 10;     // 10ms
+        syncConfig.smoothingWindow = 10;         // 10个样本
+        syncConfig.enableAdaptiveSync = true;
+        syncConfig.enableFrameDrop = true;
+        syncConfig.enableFrameDuplicate = true;
+        syncConfig.enablePrediction = true;
+        syncConfig.enableErrorRecovery = true;
+        
+        // 创建播放器实例
+        auto player = std::make_unique<PlayerCoreV2>(syncConfig);
+        
+        // 创建事件回调
+        auto callback = std::make_unique<ExamplePlayerCallback>();
+        player->setEventCallback(callback.get());
+        
+        // 如果命令行提供了文件名，自动打开
+        if (argc > 1) {
+            std::string filename = argv[1];
+            std::cout << "Opening file: " << filename << std::endl;
+            
+            auto result = player->openFile(filename);
+            if (result == ErrorCode::SUCCESS) {
+                std::cout << "File opened successfully" << std::endl;
+                
+                // 自动开始播放
+                result = player->play();
+                if (result == ErrorCode::SUCCESS) {
+                    std::cout << "Playback started" << std::endl;
+                } else {
+                    std::cout << "Failed to start playback: " << static_cast<int>(result) << std::endl;
+                }
+            } else {
+                std::cout << "Failed to open file: " << static_cast<int>(result) << std::endl;
+            }
+        }
+        
+        // 启动用户界面
+        SimplePlayerUI ui(player.get());
+        
+        // 启动更新线程
+        std::atomic<bool> shouldStop(false);
+        std::thread updateThread([&player, &shouldStop]() {
+            while (!shouldStop) {
+                player->update();
+                std::this_thread::sleep_for(std::chrono::milliseconds(16)); // ~60 FPS
+            }
+        });
+        
+        // 运行用户界面
+        ui.run();
+        
+        // 停止更新线程
+        shouldStop = true;
+        if (updateThread.joinable()) {
+            updateThread.join();
+        }
+        
+        // 停止播放器
+        player->stop();
+        
+        std::cout << "PlayerCoreV2 Example finished" << std::endl;
+        
+    } catch (const std::exception& e) {
+        std::cerr << "Exception: " << e.what() << std::endl;
+        return 1;
+    } catch (...) {
+        std::cerr << "Unknown exception occurred" << std::endl;
+        return 1;
+    }
+    
+    return 0;
+}

AV/code/player/SimplePlayerWindow.cpp

@@ -1,472 +0,0 @@
-#include "SimplePlayerWindow.h"
-#include <QFileDialog>
-#include <QMessageBox>
-#include <QDebug>
-#include <QFileInfo>
-
-SimplePlayerWindow::SimplePlayerWindow(QWidget *parent)
-    : QMainWindow(parent)
-    , m_openGLVideoRenderer(nullptr)
-{
-    qDebug() << "Initializing SimplePlayerWindow...";
-    
-    try {
-        // 创建播放器适配器
-        m_playerAdapter = PlayerAdapterFactory::create(this);
-        if (!m_playerAdapter) {
-            throw std::runtime_error("Failed to create PlayerAdapter");
-        }
-        
-        qDebug() << "PlayerAdapter created successfully";
-        
-        setupUI();
-        connectSignals();
-        updateUI();
-        
-        // 设置OpenGL渲染器
-        if (m_openGLVideoRenderer && m_playerAdapter) {
-            qDebug() << "Setting OpenGL video renderer...";
-            m_playerAdapter->setOpenGLVideoRenderer(m_openGLVideoRenderer);
-        } else {
-            qWarning() << "No video renderer available";
-        }
-        
-        setWindowTitle("Simple Media Player (OpenGL)");
-        resize(800, 600);
-        
-        qDebug() << "SimplePlayerWindow initialized successfully";
-        
-    } catch (const std::exception& e) {
-        qCritical() << "Exception during SimplePlayerWindow initialization:" << e.what();
-        QMessageBox::critical(this, "Initialization Error", 
-            QString("Failed to initialize player window: %1").arg(e.what()));
-        throw;
-    } catch (...) {
-        qCritical() << "Unknown exception during SimplePlayerWindow initialization";
-        QMessageBox::critical(this, "Initialization Error", 
-            "Unknown error during player window initialization");
-        throw;
-    }
-}
-
-SimplePlayerWindow::~SimplePlayerWindow()
-{
-    if (m_playerAdapter) {
-        m_playerAdapter->stop();
-    }
-}
-
-void SimplePlayerWindow::openFile()
-{
-    qDebug() << "Opening file dialog...";
-    
-    QString filename = QFileDialog::getOpenFileName(
-        this,
-        "Open Media File",
-        "",
-        "Media Files (*.mp4 *.avi *.mkv *.mov *.wmv *.flv *.webm *.mp3 *.wav *.aac *.flac *.ogg);;All Files (*.*)"
-    );
-    
-    if (!filename.isEmpty()) {
-        qDebug() << "Selected file:" << filename;
-        
-        // 检查文件是否存在
-        QFileInfo fileInfo(filename);
-        if (!fileInfo.exists()) {
-            QMessageBox::critical(this, "Error", "File does not exist: " + filename);
-            return;
-        }
-        
-        if (!fileInfo.isReadable()) {
-            QMessageBox::critical(this, "Error", "File is not readable: " + filename);
-            return;
-        }
-        
-        // 显示加载状态
-        m_stateLabel->setText("State: Loading...");
-        m_fileLabel->setText("Loading: " + fileInfo.fileName());
-        
-        // 尝试打开文件
-        av::ErrorCode result = m_playerAdapter->openFile(filename);
-        
-        if (result != av::ErrorCode::SUCCESS) {
-            QString errorMsg = "Failed to open file: " + filename;
-            
-            // 根据错误代码提供更具体的错误信息
-            switch (result) {
-                case av::ErrorCode::FILE_OPEN_FAILED:
-                    errorMsg = "Could not open file. Please check if the file is corrupted or in an unsupported format.";
-                    break;
-                case av::ErrorCode::CODEC_OPEN_FAILED:
-                    errorMsg = "Could not initialize codecs. The file format may not be supported.";
-                    break;
-                case av::ErrorCode::NOT_INITIALIZED:
-                    errorMsg = "Player not properly initialized. Please restart the application.";
-                    break;
-                case av::ErrorCode::INVALID_STATE:
-                    errorMsg = "Player is in an invalid state. Please try again.";
-                    break;
-                default:
-                    errorMsg = "Unknown error occurred while opening the file.";
-                    break;
-            }
-            
-            QMessageBox::critical(this, "Error", errorMsg);
-            qCritical() << "Failed to open file:" << filename << "Error code:" << static_cast<int>(result);
-            
-            // 重置状态
-            m_stateLabel->setText("State: Idle");
-            m_fileLabel->setText("No file loaded");
-        } else {
-            m_fileLabel->setText("File: " + fileInfo.fileName());
-            qDebug() << "File opened successfully:" << filename;
-        }
-    } else {
-        qDebug() << "No file selected";
-    }
-}
-
-void SimplePlayerWindow::playPause()
-{
-    if (!m_playerAdapter) {
-        qWarning() << "PlayerAdapter is null";
-        return;
-    }
-    
-    PlayerState state = m_playerAdapter->getState();
-    qDebug() << "Current player state:" << static_cast<int>(state);
-    
-    if (state == PlayerState::Playing) {
-        qDebug() << "Pausing playback...";
-        av::ErrorCode result = m_playerAdapter->pause();
-        if (result != av::ErrorCode::SUCCESS) {
-            qWarning() << "Failed to pause playback, error code:" << static_cast<int>(result);
-        }
-    } else if (state == PlayerState::Paused || state == PlayerState::Stopped) {
-        qDebug() << "Starting playback...";
-        av::ErrorCode result = m_playerAdapter->play();
-        if (result != av::ErrorCode::SUCCESS) {
-            qWarning() << "Failed to start playback, error code:" << static_cast<int>(result);
-            QMessageBox::warning(this, "Playback Error", 
-                "Failed to start playback. Please check if a file is loaded.");
-        }
-    } else if (state == PlayerState::Idle) {
-        QMessageBox::information(this, "Information", 
-            "Please open a media file first.");
-    } else {
-        qDebug() << "Player is in state:" << static_cast<int>(state) << "- cannot play/pause";
-    }
-}
-
-void SimplePlayerWindow::stop()
-{
-    m_playerAdapter->stop();
-}
-
-void SimplePlayerWindow::seek()
-{
-    if (m_seeking) {
-        qint64 duration = m_playerAdapter->getDuration();
-        qint64 position = (duration * m_positionSlider->value()) / 1000;
-        m_playerAdapter->seek(position);
-    }
-}
-
-void SimplePlayerWindow::setVolume()
-{
-    double volume = m_volumeSlider->value() / 100.0;
-    m_playerAdapter->setVolume(volume);
-    m_volumeLabel->setText(QString("Volume: %1%").arg(m_volumeSlider->value()));
-}
-
-void SimplePlayerWindow::toggleMute()
-{
-    bool muted = m_playerAdapter->isMuted();
-    m_playerAdapter->setMuted(!muted);
-}
-
-void SimplePlayerWindow::setPlaybackSpeed()
-{
-    double speed = m_speedSlider->value() / 100.0;
-    m_playerAdapter->setPlaybackSpeed(speed);
-    m_speedLabel->setText(QString("Speed: %1x").arg(speed, 0, 'f', 2));
-}
-
-void SimplePlayerWindow::onStateChanged(PlayerState state)
-{
-    QString stateText;
-    switch (state) {
-        case PlayerState::Idle:
-            stateText = "Idle";
-            break;
-        // case PlayerState::Loading:
-        //     stateText = "Loading";
-        //     break;
-        case PlayerState::Playing:
-            stateText = "Playing";
-            break;
-        case PlayerState::Paused:
-            stateText = "Paused";
-            break;
-        case PlayerState::Stopped:
-            stateText = "Stopped";
-            break;
-        case PlayerState::Error:
-            stateText = "Error";
-            break;
-    }
-    
-    m_stateLabel->setText("State: " + stateText);
-    updateUI();
-}
-
-void SimplePlayerWindow::onMediaInfoChanged(const MediaInfo& info)
-{
-    QString infoText = QString("Duration: %1 | Video: %2x%3 | Audio: %4 Hz")
-                           .arg(formatTime(info.duration))
-                           .arg(info.width)
-                           .arg(info.height)
-                           .arg(info.audioSampleRate);
-
-    m_infoLabel->setText(infoText);
-}
-
-void SimplePlayerWindow::onPositionChanged(qint64 position)
-{
-    if (!m_seeking) {
-        qint64 duration = m_playerAdapter->getDuration();
-        if (duration > 0) {
-            int sliderValue = (position * 1000) / duration;
-            m_positionSlider->setValue(sliderValue);
-        }
-        
-        QString timeText = QString("%1 / %2")
-                               .arg(formatTime(position))
-                               .arg(formatTime(duration));
-        m_timeLabel->setText(timeText);
-    }
-}
-
-void SimplePlayerWindow::onVolumeChanged(double volume)
-{
-    int volumePercent = static_cast<int>(volume * 100);
-    m_volumeSlider->setValue(volumePercent);
-    m_volumeLabel->setText(QString("Volume: %1%").arg(volumePercent));
-}
-
-void SimplePlayerWindow::onMutedChanged(bool muted)
-{
-    m_muteButton->setText(muted ? "Unmute" : "Mute");
-}
-
-void SimplePlayerWindow::onPlaybackSpeedChanged(double speed)
-{
-    int speedPercent = static_cast<int>(speed * 100);
-    m_speedSlider->setValue(speedPercent);
-    m_speedLabel->setText(QString("Speed: %1x").arg(speed, 0, 'f', 2));
-}
-
-void SimplePlayerWindow::onErrorOccurred(const QString& error)
-{
-    QMessageBox::critical(this, "Player Error", error);
-    qDebug() << "Player error:" << error;
-}
-
-void SimplePlayerWindow::onStatsUpdated(const PlaybackStats& stats)
-{
-    QString statsText = QString("Packets: %1 | Video Frames: %2 | Audio Frames: %3")
-                            .arg(stats.queuedPackets)
-                            .arg(stats.queuedVideoFrames)
-                            .arg(stats.queuedAudioFrames);
-    
-    m_statsLabel->setText(statsText);
-}
-
-void SimplePlayerWindow::setupUI()
-{
-    auto* centralWidget = new QWidget(this);
-    setCentralWidget(centralWidget);
-
-    auto* mainLayout = new QVBoxLayout(centralWidget);
-
-    // 文件信息
-    m_fileLabel = new QLabel("No file loaded");
-    m_stateLabel = new QLabel("State: Idle");
-    m_infoLabel = new QLabel("Media info will appear here");
-
-    mainLayout->addWidget(m_fileLabel);
-    mainLayout->addWidget(m_stateLabel);
-    mainLayout->addWidget(m_infoLabel);
-    
-    // 视频渲染器 - 使用OpenGL渲染器
-    m_openGLVideoRenderer = new OpenGLVideoRenderer(this);
-    m_openGLVideoRenderer->setMinimumSize(640, 480);
-    m_openGLVideoRenderer->setStyleSheet("border: 1px solid gray;");
-    mainLayout->addWidget(m_openGLVideoRenderer);
-
-    // 控制按钮
-    auto* buttonLayout = new QHBoxLayout();
-
-    m_openButton = new QPushButton("Open File");
-    m_playPauseButton = new QPushButton("Play");
-    m_stopButton = new QPushButton("Stop");
-
-    buttonLayout->addWidget(m_openButton);
-    buttonLayout->addWidget(m_playPauseButton);
-    buttonLayout->addWidget(m_stopButton);
-    buttonLayout->addStretch();
-
-    mainLayout->addLayout(buttonLayout);
-
-    // 进度控制
-    auto* progressLayout = new QHBoxLayout();
-
-    m_timeLabel = new QLabel("00:00 / 00:00");
-    m_positionSlider = new QSlider(Qt::Horizontal);
-    m_positionSlider->setRange(0, 1000);
-
-    progressLayout->addWidget(m_timeLabel);
-    progressLayout->addWidget(m_positionSlider);
-
-    mainLayout->addLayout(progressLayout);
-
-    // 音量控制
-    auto* volumeLayout = new QHBoxLayout();
-
-    m_volumeLabel = new QLabel("Volume: 100%");
-    m_volumeSlider = new QSlider(Qt::Horizontal);
-    m_volumeSlider->setRange(0, 100);
-    m_volumeSlider->setValue(100);
-    m_muteButton = new QPushButton("Mute");
-
-    volumeLayout->addWidget(m_volumeLabel);
-    volumeLayout->addWidget(m_volumeSlider);
-    volumeLayout->addWidget(m_muteButton);
-
-    mainLayout->addLayout(volumeLayout);
-
-    // 播放速度控制
-    auto* speedLayout = new QHBoxLayout();
-
-    m_speedLabel = new QLabel("Speed: 1.00x");
-    m_speedSlider = new QSlider(Qt::Horizontal);
-    m_speedSlider->setRange(25, 400); // 0.25x to 4.0x
-    m_speedSlider->setValue(100);
-
-    speedLayout->addWidget(m_speedLabel);
-    speedLayout->addWidget(m_speedSlider);
-
-    mainLayout->addLayout(speedLayout);
-
-    // 统计信息
-    m_statsLabel = new QLabel("Statistics will appear here");
-    mainLayout->addWidget(m_statsLabel);
-
-    mainLayout->addStretch();
-}
-
-void SimplePlayerWindow::connectSignals()
-{
-    // UI信号
-    connect(m_openButton, &QPushButton::clicked, this, &SimplePlayerWindow::openFile);
-    connect(m_playPauseButton, &QPushButton::clicked, this, &SimplePlayerWindow::playPause);
-    connect(m_stopButton, &QPushButton::clicked, this, &SimplePlayerWindow::stop);
-
-    connect(m_positionSlider, &QSlider::sliderPressed, [this]() { m_seeking = true; });
-    connect(m_positionSlider, &QSlider::sliderReleased, [this]() {
-        seek();
-        m_seeking = false;
-    });
-
-    connect(m_volumeSlider, &QSlider::valueChanged, this, &SimplePlayerWindow::setVolume);
-    connect(m_muteButton, &QPushButton::clicked, this, &SimplePlayerWindow::toggleMute);
-    connect(m_speedSlider, &QSlider::valueChanged, this, &SimplePlayerWindow::setPlaybackSpeed);
-
-    // 播放器信号
-    connect(m_playerAdapter.get(),
-            &PlayerAdapter::stateChanged,
-            this,
-            &SimplePlayerWindow::onStateChanged);
-    connect(m_playerAdapter.get(),
-            &PlayerAdapter::mediaInfoChanged,
-            this,
-            &SimplePlayerWindow::onMediaInfoChanged);
-    connect(m_playerAdapter.get(),
-            &PlayerAdapter::positionChanged,
-            this,
-            &SimplePlayerWindow::onPositionChanged);
-    connect(m_playerAdapter.get(),
-            &PlayerAdapter::volumeChanged,
-            this,
-            &SimplePlayerWindow::onVolumeChanged);
-    connect(m_playerAdapter.get(),
-            &PlayerAdapter::mutedChanged,
-            this,
-            &SimplePlayerWindow::onMutedChanged);
-    connect(m_playerAdapter.get(),
-            &PlayerAdapter::playbackSpeedChanged,
-            this,
-            &SimplePlayerWindow::onPlaybackSpeedChanged);
-    connect(m_playerAdapter.get(),
-            &PlayerAdapter::errorOccurred,
-            this,
-            &SimplePlayerWindow::onErrorOccurred);
-    connect(m_playerAdapter.get(),
-            &PlayerAdapter::statsUpdated,
-            this,
-            &SimplePlayerWindow::onStatsUpdated);
-    
-    // 渲染器相关信号
-    connect(m_playerAdapter.get(),
-            &PlayerAdapter::rendererTypeChanged,
-            this,
-            &SimplePlayerWindow::onRendererTypeChanged);
-    connect(m_playerAdapter.get(),
-            &PlayerAdapter::openGLRendererInitialized,
-            this,
-            &SimplePlayerWindow::onOpenGLRendererInitialized);
-}
-
-void SimplePlayerWindow::updateUI()
-{
-    PlayerState state = m_playerAdapter->getState();
-
-    // 更新播放/暂停按钮
-    if (state == PlayerState::Playing) {
-        m_playPauseButton->setText("Pause");
-    } else {
-        m_playPauseButton->setText("Play");
-    }
-
-    // 更新按钮可用状态
-    bool hasMedia = (state != PlayerState::Idle);
-    m_playPauseButton->setEnabled(hasMedia);
-    m_stopButton->setEnabled(hasMedia);
-    m_positionSlider->setEnabled(hasMedia);
-}
-
-void SimplePlayerWindow::onRendererTypeChanged(const QString& type)
-{
-    qDebug() << "Renderer type changed to:" << type;
-    
-    // 更新窗口标题显示当前渲染器类型
-    QString title = QString("Simple Media Player (%1)").arg(type);
-    setWindowTitle(title);
-}
-
-void SimplePlayerWindow::onOpenGLRendererInitialized()
-{
-    qDebug() << "OpenGL renderer initialized successfully";
-    
-    // 可以在这里添加OpenGL渲染器初始化完成后的逻辑
-    // 比如显示一些OpenGL特定的信息
-}
-
-QString SimplePlayerWindow::formatTime(qint64 microseconds)
-{
-    qint64 seconds = microseconds / 1000000;
-    qint64 minutes = seconds / 60;
-    seconds %= 60;
-
-    return QString("%1:%2").arg(minutes, 2, 10, QChar('0')).arg(seconds, 2, 10, QChar('0'));
-}

AV/code/player/SimplePlayerWindow.h

@@ -1,87 +0,0 @@
-#ifndef SIMPLEPLAYERWINDOW_H
-#define SIMPLEPLAYERWINDOW_H
-
-#include <QApplication>
-#include <QDebug>
-#include <QFileDialog>
-#include <QHBoxLayout>
-#include <QLabel>
-#include <QMainWindow>
-#include <QMessageBox>
-#include <QPushButton>
-#include <QSlider>
-#include <QTimer>
-#include <QVBoxLayout>
-#include "player_adapter.h"
-#include "opengl_video_renderer.h"
-
-using namespace av::player;
-
-/**
- * @brief 简单的播放器UI示例
- * 
- * 这个类展示了如何使用新的PlayerAdapter来构建播放器UI
- */
-class SimplePlayerWindow : public QMainWindow
-{
-    Q_OBJECT
-
-public:
-    explicit SimplePlayerWindow(QWidget* parent = nullptr);
-    ~SimplePlayerWindow();
-private slots:
-    void openFile();
-    void playPause();
-    void stop();
-    void seek();
-    void setVolume();
-    void toggleMute();
-    void setPlaybackSpeed();
-
-    // 播放器事件处理
-    void onStateChanged(PlayerState state);
-    void onMediaInfoChanged(const MediaInfo& info);
-    void onPositionChanged(qint64 position);
-    void onVolumeChanged(double volume);
-    void onMutedChanged(bool muted);
-    void onPlaybackSpeedChanged(double speed);
-    void onErrorOccurred(const QString& error);
-
-    void onStatsUpdated(const PlaybackStats& stats);
-    
-    // 渲染器相关
-    void onRendererTypeChanged(const QString& type);
-    void onOpenGLRendererInitialized();
-
-private:
-    void setupUI();
-    void connectSignals();
-    void updateUI();
-    QString formatTime(qint64 microseconds);
-
-private:
-    std::unique_ptr<PlayerAdapter> m_playerAdapter;
-    OpenGLVideoRenderer* m_openGLVideoRenderer;
-
-    // UI组件
-    QLabel* m_fileLabel;
-    QLabel* m_stateLabel;
-    QLabel* m_infoLabel;
-    QLabel* m_timeLabel;
-    QLabel* m_volumeLabel;
-    QLabel* m_speedLabel;
-    QLabel* m_statsLabel;
-
-    QPushButton* m_openButton;
-    QPushButton* m_playPauseButton;
-    QPushButton* m_stopButton;
-    QPushButton* m_muteButton;
-
-    QSlider* m_positionSlider;
-    QSlider* m_volumeSlider;
-    QSlider* m_speedSlider;
-
-    bool m_seeking = false;
-};
-
-#endif // SIMPLEPLAYERWINDOW_H

AV/code/player/audio_output.cpp

@@ -1,5 +1,6 @@
 #include "audio_output.h"
 #include "../base/logger.h"
+#include "../utils/utils_synchronizer_v2.h"
 #include <QAudioDeviceInfo>
 #include <QDebug>
 #include <algorithm>
@@ -150,30 +151,72 @@ void AudioOutput::start()
             std::to_string(nearestFormat.sampleSize()) + "bit");
     }
     
-    m_audioDevice = m_audioOutput->start();
-    if (!m_audioDevice) {
-        av::Logger::instance().error("Failed to start audio output device");
-        return;
-    }
-    
-    av::Logger::instance().debug("Audio device started, waiting for active state...");
+    // 尝试多次启动音频设备
+    int retryCount = 0;
+    const int maxRetries = 3;
+    bool deviceStarted = false;
     
-    // 等待音频设备进入活动状态
-    int maxWaitMs = 2000; // 最多等待2秒
-    int waitMs = 0;
-    while (m_audioOutput->state() != QAudio::ActiveState && waitMs < maxWaitMs) {
-        std::this_thread::sleep_for(std::chrono::milliseconds(10));
-        waitMs += 10;
+    while (retryCount < maxRetries && !deviceStarted) {
+        if (retryCount > 0) {
+            av::Logger::instance().info("Retrying audio device start (attempt " + std::to_string(retryCount + 1) + "/" + std::to_string(maxRetries) + ")");
+            
+            // 重新创建音频输出设备
+            if (m_audioOutput) {
+                delete m_audioOutput;
+                m_audioOutput = nullptr;
+            }
+            
+            m_audioOutput = new QAudioOutput(m_audioFormat, this);
+            if (!m_audioOutput) {
+                av::Logger::instance().error("Failed to recreate audio output device");
+                return;
+            }
+            
+            m_audioOutput->setBufferSize(32768);
+            connect(m_audioOutput, &QAudioOutput::stateChanged, this, &AudioOutput::onStateChanged);
+            
+            // 等待一段时间再重试
+            std::this_thread::sleep_for(std::chrono::milliseconds(200));
+        }
+        
+        m_audioDevice = m_audioOutput->start();
+        if (!m_audioDevice) {
+            av::Logger::instance().warning("Failed to start audio output device (attempt " + std::to_string(retryCount + 1) + ")");
+            retryCount++;
+            continue;
+        }
+        
+        av::Logger::instance().debug("Audio device started, waiting for active state...");
+        
+        // 写入一些静音数据来激活设备
+        QByteArray silentData(1024, 0); // 1KB的静音数据
+        m_audioDevice->write(silentData);
+        
+        // 等待音频设备进入活动状态
+        int maxWaitMs = 1000; // 减少等待时间到1秒
+        int waitMs = 0;
+        while (m_audioOutput->state() != QAudio::ActiveState && waitMs < maxWaitMs) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(50));
+            waitMs += 50;
+            
+            if (waitMs % 200 == 0) {
+                av::Logger::instance().debug("Audio output state: " + std::to_string(m_audioOutput->state()) + 
+                    " (waited " + std::to_string(waitMs) + "ms)");
+            }
+        }
         
-        if (waitMs % 100 == 0) {
-            av::Logger::instance().debug("Audio output state: " + std::to_string(m_audioOutput->state()) + 
-                " (waited " + std::to_string(waitMs) + "ms)");
+        if (m_audioOutput->state() == QAudio::ActiveState) {
+            deviceStarted = true;
+            av::Logger::instance().info("Audio device successfully entered active state");
+        } else {
+            av::Logger::instance().warning("Audio device failed to enter active state: " + std::to_string(m_audioOutput->state()) + " (attempt " + std::to_string(retryCount + 1) + ")");
+            m_audioDevice = nullptr;
+            retryCount++;
         }
     }
     
-    if (m_audioOutput->state() != QAudio::ActiveState) {
-        av::Logger::instance().error("Audio device failed to enter active state: " + std::to_string(m_audioOutput->state()));
-        m_audioDevice = nullptr;
+    if (!deviceStarted) {
+        av::Logger::instance().error("Failed to start audio device after " + std::to_string(maxRetries) + " attempts");
         return;
     }
     
@@ -181,11 +224,11 @@ void AudioOutput::start()
     
     // 初始化并启动Synchronizer
     if (!m_synchronizer) {
-        av::utils::SyncConfig syncConfig;
-        syncConfig.strategy = av::utils::SyncStrategy::AUDIO_MASTER;
-        syncConfig.syncThreshold = 0.04;  // 40ms，与AVPlayer2一致
-        syncConfig.maxAudioDelay = 0.1;   // 100ms
-        m_synchronizer = std::make_shared<av::utils::Synchronizer>(syncConfig);
+        av::utils::SyncConfigV2 syncConfig;
+        syncConfig.syncStrategy = av::utils::SyncStrategy::AUDIO_MASTER;
+        syncConfig.audioSyncThreshold = 0.04;  // 40ms，与AVPlayer2一致
+        syncConfig.videoSyncThreshold = 0.04;
+        m_synchronizer = std::make_shared<av::utils::SynchronizerV2>(syncConfig);
         m_synchronizer->initialize();
         m_synchronizer->start();
     }
@@ -261,7 +304,8 @@ bool AudioOutput::writeFrame(const AVFramePtr& frame)
         
         // 计算同步延迟
         double delay = 0.0;
-        ErrorCode result = m_synchronizer->synchronizeAudio(audioPts, delay);
+        ErrorCode result = m_synchronizer->shouldPlayAudioFrame(audioPts).action == av::utils::FrameAction::DISPLAY ? ErrorCode::SUCCESS : ErrorCode::PROCESSING_ERROR;
+        delay = m_synchronizer->shouldPlayAudioFrame(audioPts).delay;
         
         if (result == ErrorCode::SUCCESS && delay > 0) {
             // 应用播放速度控制

AV/code/player/audio_output.h

@@ -20,7 +20,7 @@ extern "C" {
 }
 
 #include "../base/media_common.h"
-#include "../utils/utils_synchronizer.h"
+#include "../utils/utils_synchronizer_v2.h"
 
 namespace av {
 namespace player {
@@ -159,7 +159,7 @@ private:
     std::atomic<bool> m_playing;
     
     // 时间同步 - 使用Synchronizer进行统一管理
-    std::shared_ptr<av::utils::Synchronizer> m_synchronizer;
+    std::shared_ptr<av::utils::SynchronizerV2> m_synchronizer;
     double m_lastAudioPts;  // 上一次的音频PTS
     
     mutable QMutex m_mutex;

AV/code/player/player.pri

@@ -1,15 +1,12 @@
+# PlayerV2 Core Components
 HEADERS += \
-    $$PWD/SimplePlayerWindow.h \
+    $$PWD/player_core_v2.h \
     $$PWD/audio_output.h \
     $$PWD/opengl_video_renderer.h \
-    $$PWD/player_adapter.h \
-    $$PWD/player_core.h \
     $$PWD/thread_manager.h
 
 SOURCES += \
-    $$PWD/SimplePlayerWindow.cpp \
+    $$PWD/player_core_v2.cpp \
     $$PWD/audio_output.cpp \
     $$PWD/opengl_video_renderer.cpp \
-    $$PWD/player_adapter.cpp \
-    $$PWD/player_core.cpp \
     $$PWD/thread_manager.cpp

AV/code/player/player_adapter.cpp

@@ -1,354 +0,0 @@
-#include "player_adapter.h"
-#include "opengl_video_renderer.h"
-#include "../base/media_common.h"
-#include <QDebug>
-#include <QMetaType>
-
-namespace av {
-namespace player {
-
-// 注册Qt元类型
-static int registerMetaTypes() {
-    qRegisterMetaType<PlayerState>("PlayerState");
-    qRegisterMetaType<MediaInfo>("MediaInfo");
-    qRegisterMetaType<PlaybackStats>("PlaybackStats");
-    qRegisterMetaType<av::ErrorCode>("av::ErrorCode");
-    return 0;
-}
-static int dummy = registerMetaTypes();
-
-PlayerAdapter::PlayerAdapter(QObject* parent)
-    : QObject(parent)
-    , m_playerCore(std::make_unique<PlayerCore>())
-    , m_updateTimer(new QTimer(this))
-{
-    // 设置事件回调
-    m_playerCore->setEventCallback(this);
-    
-    // 连接更新定时器
-    connect(m_updateTimer, &QTimer::timeout, this, &PlayerAdapter::updatePlayer);
-    
-    qDebug() << "PlayerAdapter created";
-}
-
-PlayerAdapter::~PlayerAdapter()
-{
-    stopUpdateTimer();
-    qDebug() << "PlayerAdapter destroyed";
-}
-
-void PlayerAdapter::setOpenGLVideoRenderer(OpenGLVideoRenderer* renderer)
-{
-    if (m_playerCore) {
-        m_playerCore->setOpenGLVideoRenderer(renderer);
-        m_openGLVideoRenderer = renderer;
-        updateRendererType();
-        
-        // 如果OpenGL渲染器初始化完成，发送信号
-        if (renderer && renderer->isInitialized()) {
-            emit openGLRendererInitialized();
-        }
-    }
-}
-
-av::ErrorCode PlayerAdapter::openFile(const QString& filename)
-{
-    std::string stdFilename = filename.toStdString();
-    av::ErrorCode result = m_playerCore->openFile(stdFilename);
-    
-    if (result == av::ErrorCode::SUCCESS) {
-        // 启动更新定时器
-        startUpdateTimer();
-        
-        // 检查渲染器状态
-        if (m_openGLVideoRenderer && m_openGLVideoRenderer->isInitialized()) {
-            emit openGLRendererInitialized();
-        }
-        
-        qDebug() << "File opened successfully:" << filename;
-        qDebug() << "Current renderer type:" << m_currentRendererType;
-    }
-    
-    return result;
-}
-
-av::ErrorCode PlayerAdapter::play()
-{
-    return m_playerCore->play();
-}
-
-av::ErrorCode PlayerAdapter::pause()
-{
-    return m_playerCore->pause();
-}
-
-av::ErrorCode PlayerAdapter::stop()
-{
-    av::ErrorCode result = m_playerCore->stop();
-    
-    if (result == av::ErrorCode::SUCCESS) {
-        // 停止更新定时器
-        stopUpdateTimer();
-    }
-    
-    return result;
-}
-
-av::ErrorCode PlayerAdapter::seek(qint64 timestamp)
-{
-    return m_playerCore->seek(timestamp);
-}
-
-av::ErrorCode PlayerAdapter::setPlaybackSpeed(double speed)
-{
-    av::ErrorCode result = m_playerCore->setPlaybackSpeed(speed);
-    
-    if (result == av::ErrorCode::SUCCESS && std::abs(m_lastPlaybackSpeed - speed) > 0.001) {
-        m_lastPlaybackSpeed = speed;
-        emit playbackSpeedChanged(speed);
-    }
-    
-    return result;
-}
-
-PlayerState PlayerAdapter::getState() const
-{
-    return m_playerCore->getState();
-}
-
-qint64 PlayerAdapter::getCurrentTime() const
-{
-    return m_playerCore->getCurrentTime();
-}
-
-qint64 PlayerAdapter::getDuration() const
-{
-    MediaInfo info = m_playerCore->getMediaInfo();
-    return info.duration;
-}
-
-double PlayerAdapter::getPlaybackSpeed() const
-{
-    return m_playerCore->getPlaybackSpeed();
-}
-
-void PlayerAdapter::setVolume(double volume)
-{
-    m_playerCore->setVolume(volume);
-    
-    if (std::abs(m_lastVolume - volume) > 0.001) {
-        m_lastVolume = volume;
-        emit volumeChanged(volume);
-    }
-}
-
-double PlayerAdapter::getVolume() const
-{
-    return m_playerCore->getVolume();
-}
-
-void PlayerAdapter::setMuted(bool muted)
-{
-    if (m_muted != muted) {
-        m_muted = muted;
-        
-        // 如果静音，设置音量为0；否则恢复之前的音量
-        if (muted) {
-            m_playerCore->setVolume(0.0);
-        } else {
-            m_playerCore->setVolume(m_lastVolume);
-        }
-        
-        emit mutedChanged(muted);
-    }
-}
-
-bool PlayerAdapter::isMuted() const
-{
-    return m_muted;
-}
-
-MediaInfo PlayerAdapter::getMediaInfo() const
-{
-    return m_playerCore->getMediaInfo();
-}
-
-PlaybackStats PlayerAdapter::getStats() const
-{
-    return m_playerCore->getStats();
-}
-
-AVFrame* PlayerAdapter::getNextVideoFrame()
-{
-    return m_playerCore->getNextVideoFrame();
-}
-
-AVFrame* PlayerAdapter::getNextAudioFrame()
-{
-    return m_playerCore->getNextAudioFrame();
-}
-
-void PlayerAdapter::releaseVideoFrame(AVFrame* frame)
-{
-    m_playerCore->releaseVideoFrame(frame);
-}
-
-void PlayerAdapter::releaseAudioFrame(AVFrame* frame)
-{
-    m_playerCore->releaseAudioFrame(frame);
-}
-
-void PlayerAdapter::startUpdateTimer(int intervalMs)
-{
-    if (!m_updateTimer->isActive()) {
-        m_updateTimer->start(intervalMs);
-        qDebug() << "Update timer started with interval:" << intervalMs << "ms";
-    }
-}
-
-void PlayerAdapter::stopUpdateTimer()
-{
-    if (m_updateTimer->isActive()) {
-        m_updateTimer->stop();
-        qDebug() << "Update timer stopped";
-    }
-}
-
-void PlayerAdapter::updatePlayer()
-{
-    // 更新播放器核心
-    m_playerCore->update();
-    
-    // 检查状态变化
-    PlayerState currentState = m_playerCore->getState();
-    if (currentState != m_lastState) {
-        m_lastState = currentState;
-        emit stateChanged(currentState);
-    }
-    
-    // 检查位置和时长变化
-    checkPositionChanged();
-    checkDurationChanged();
-    
-    // 发送统计信息更新
-    PlaybackStats stats = m_playerCore->getStats();
-    emit statsUpdated(stats);
-    
-    // 检查是否有新的视频帧
-    if (m_playerCore->getNextVideoFrame() != nullptr) {
-        emit videoFrameAvailable();
-    }
-    
-    // 检查是否有新的音频帧
-    if (m_playerCore->getNextAudioFrame() != nullptr) {
-        emit audioFrameAvailable();
-    }
-}
-
-void PlayerAdapter::onStateChanged(PlayerState state)
-{
-    // 在主线程中发送信号
-    QMetaObject::invokeMethod(this, [this, state]() {
-        if (state != m_lastState) {
-            m_lastState = state;
-            emit stateChanged(state);
-        }
-    }, Qt::QueuedConnection);
-}
-
-void PlayerAdapter::onMediaInfoChanged(const MediaInfo& info)
-{
-    // 在主线程中发送信号
-    QMetaObject::invokeMethod(this, [this, info]() {
-        emit mediaInfoChanged(info);
-        
-        // 检查时长变化
-        if (info.duration != m_lastDuration) {
-            m_lastDuration = info.duration;
-            emit durationChanged(info.duration);
-        }
-    }, Qt::QueuedConnection);
-}
-
-void PlayerAdapter::onPositionChanged(int64_t position)
-{
-    // 在主线程中发送信号
-    QMetaObject::invokeMethod(this, [this, position]() {
-        if (std::abs(position - m_lastPosition) > 100000) { // 100ms阈值(微秒)
-            m_lastPosition = position;
-            emit positionChanged(position);
-        }
-    }, Qt::QueuedConnection);
-}
-
-void PlayerAdapter::onErrorOccurred(const std::string& error)
-{
-    QString qError = toQString(error);
-    
-    // 在主线程中发送信号
-    QMetaObject::invokeMethod(this, [this, qError]() {
-        emit errorOccurred(qError);
-    }, Qt::QueuedConnection);
-}
-
-void PlayerAdapter::onEndOfFile()
-{
-    // 在主线程中发送信号
-    QMetaObject::invokeMethod(this, [this]() {
-        emit playbackFinished();
-        stopUpdateTimer();
-    }, Qt::QueuedConnection);
-}
-
-void PlayerAdapter::checkPositionChanged()
-{
-    qint64 currentPosition = getCurrentTime();
-    if (std::abs(currentPosition - m_lastPosition) > 100) { // 100ms阈值
-        m_lastPosition = currentPosition;
-        emit positionChanged(currentPosition);
-    }
-}
-
-void PlayerAdapter::checkDurationChanged()
-{
-    qint64 currentDuration = getDuration();
-    if (currentDuration != m_lastDuration) {
-        m_lastDuration = currentDuration;
-        emit durationChanged(currentDuration);
-    }
-}
-
-QString PlayerAdapter::toQString(const std::string& str) const
-{
-    return QString::fromStdString(str);
-}
-
-void PlayerAdapter::updateRendererType()
-{
-    QString newType = "None";
-    
-    if (m_openGLVideoRenderer) {
-        newType = "OpenGL";
-    }
-    
-    if (newType != m_currentRendererType) {
-        m_currentRendererType = newType;
-        emit rendererTypeChanged(newType);
-        qDebug() << "Renderer type changed to:" << newType;
-    }
-}
-
-// PlayerAdapterFactory 实现
-std::unique_ptr<PlayerAdapter> PlayerAdapterFactory::create(QObject* parent)
-{
-    return std::make_unique<PlayerAdapter>(parent);
-}
-
-std::shared_ptr<PlayerAdapter> PlayerAdapterFactory::createShared(QObject* parent)
-{
-    return std::make_shared<PlayerAdapter>(parent);
-}
-
-} // namespace player
-} // namespace av
-

AV/code/player/player_adapter.h

@@ -1,220 +0,0 @@
-#pragma once
-
-#include "player_core.h"
-#include "opengl_video_renderer.h"
-
-#include <QObject>
-#include <QTimer>
-#include <memory>
-
-namespace av {
-namespace player {
-
-/**
- * @brief 播放器适配器，用于将新的播放器核心与Qt UI进行集成
- * 
- * 这个类作为新播放器核心和现有AVPlayer2 UI之间的桥梁，
- * 提供Qt信号槽机制，便于UI集成
-    */
-class PlayerAdapter : public QObject, public PlayerEventCallback
-{
-    Q_OBJECT
-public:
-    explicit PlayerAdapter(QObject* parent = nullptr);
-    ~PlayerAdapter() override;
-
-    /**
-     * @brief 获取播放器核心实例
-     */
-    PlayerCore* getPlayerCore() const { return m_playerCore.get(); }
-    
-    /**
-     * @brief 设置OpenGL视频渲染器（推荐）
-     */
-    void setOpenGLVideoRenderer(OpenGLVideoRenderer* renderer);
-    
-    // 播放控制接口
-    Q_INVOKABLE av::ErrorCode openFile(const QString& filename);
-    Q_INVOKABLE av::ErrorCode play();
-    Q_INVOKABLE av::ErrorCode pause();
-    Q_INVOKABLE av::ErrorCode stop();
-    Q_INVOKABLE av::ErrorCode seek(qint64 timestamp);
-    Q_INVOKABLE av::ErrorCode setPlaybackSpeed(double speed);
-    
-    // 状态查询接口
-    Q_INVOKABLE PlayerState getState() const;
-    Q_INVOKABLE qint64 getCurrentTime() const;
-    Q_INVOKABLE qint64 getDuration() const;
-    Q_INVOKABLE double getPlaybackSpeed() const;
-    
-    // 音量控制
-    Q_INVOKABLE void setVolume(double volume);
-    Q_INVOKABLE double getVolume() const;
-    Q_INVOKABLE void setMuted(bool muted);
-    Q_INVOKABLE bool isMuted() const;
-    
-    // 媒体信息
-    Q_INVOKABLE MediaInfo getMediaInfo() const;
-    Q_INVOKABLE PlaybackStats getStats() const;
-    
-    // 帧获取接口（用于视频渲染器）
-    AVFrame* getNextVideoFrame();
-    AVFrame* getNextAudioFrame();
-    void releaseVideoFrame(AVFrame* frame);
-    void releaseAudioFrame(AVFrame* frame);
-    
-    // 启动/停止更新定时器
-    void startUpdateTimer(int intervalMs = 16); // 默认60fps
-    void stopUpdateTimer();
-    
-public slots:
-    /**
-     * @brief 更新播放器状态（由定时器调用）
-     */
-    void updatePlayer();
-    
-signals:
-    /**
-     * @brief 播放器状态改变信号
-     */
-    void stateChanged(PlayerState state);
-    
-    /**
-     * @brief 媒体信息改变信号
-     */
-    void mediaInfoChanged(const MediaInfo& info);
-    
-    /**
-     * @brief 播放位置改变信号
-     */
-    void positionChanged(qint64 position);
-    
-    /**
-     * @brief 播放时长改变信号
-     */
-    void durationChanged(qint64 duration);
-    
-    /**
-     * @brief 音量改变信号
-     */
-    void volumeChanged(double volume);
-    
-    /**
-     * @brief 静音状态改变信号
-     */
-    void mutedChanged(bool muted);
-    
-    /**
-     * @brief 播放速度改变信号
-     */
-    void playbackSpeedChanged(double speed);
-    
-    /**
-     * @brief 错误发生信号
-     */
-    void errorOccurred(const QString& error);
-    
-    /**
-     * @brief 播放结束信号
-     */
-    void playbackFinished();
-    
-    /**
-     * @brief 统计信息更新信号
-     */
-    void statsUpdated(const PlaybackStats& stats);
-    
-    /**
-     * @brief 新视频帧可用信号
-     */
-    void videoFrameAvailable();
-    
-    /**
-     * @brief 新音频帧可用信号
-     */
-    void audioFrameAvailable();
-    
-    /**
-     * @brief OpenGL渲染器初始化完成信号
-     */
-    void openGLRendererInitialized();
-    
-    /**
-     * @brief 渲染器类型改变信号
-     */
-    void rendererTypeChanged(const QString& type);
-    
-protected:
-    // PlayerEventCallback 接口实现
-    void onStateChanged(PlayerState state) override;
-    void onMediaInfoChanged(const MediaInfo& info) override;
-    void onPositionChanged(int64_t position) override;
-    void onErrorOccurred(const std::string& error) override;
-    void onEndOfFile() override;
-    
-private:
-    std::unique_ptr<PlayerCore> m_playerCore;
-    QTimer* m_updateTimer;
-    
-    // 渲染器管理
-    OpenGLVideoRenderer* m_openGLVideoRenderer = nullptr;
-    QString m_currentRendererType = "None";
-    
-    // 缓存的状态信息
-    PlayerState m_lastState = PlayerState::Idle;
-    qint64 m_lastPosition = 0;
-    qint64 m_lastDuration = 0;
-    double m_lastVolume = 1.0;
-    bool m_muted = false;
-    double m_lastPlaybackSpeed = 1.0;
-    
-    /**
-     * @brief 检查并发送位置变化信号
-     */
-    void checkPositionChanged();
-    
-    /**
-     * @brief 检查并发送时长变化信号
-     */
-    void checkDurationChanged();
-    
-    /**
-     * @brief 将std::string转换为QString
-     */
-    QString toQString(const std::string& str) const;
-    
-    /**
-     * @brief 更新渲染器类型
-     */
-    void updateRendererType();
-    
-    /**
-     * @brief 获取当前渲染器类型
-     */
-    QString getCurrentRendererType() const { return m_currentRendererType; }
-};
-
-/**
- * @brief 播放器适配器工厂类
- */
-class PlayerAdapterFactory {
-public:
-    /**
-     * @brief 创建播放器适配器实例
-     */
-    static std::unique_ptr<PlayerAdapter> create(QObject* parent = nullptr);
-    
-    /**
-     * @brief 创建共享的播放器适配器实例
-     */
-    static std::shared_ptr<PlayerAdapter> createShared(QObject* parent = nullptr);
-};
-
-} // namespace player
-} // namespace av
-
-// 注册Qt元类型
-Q_DECLARE_METATYPE(av::player::PlayerState)
-Q_DECLARE_METATYPE(av::player::MediaInfo)
-Q_DECLARE_METATYPE(av::player::PlaybackStats)
-Q_DECLARE_METATYPE(av::ErrorCode)

AV/code/player/player_core.cpp

@@ -1,842 +0,0 @@
-#include "player_core.h"
-#include "../base/media_common.h"
-#include "../base/logger.h"
-#include "../base/types.h"
-#include "thread_manager.h"
-#include "../codec/codec_video_decoder.h"
-#include "../codec/codec_audio_decoder.h"
-#include <chrono>
-#include <thread>
-
-namespace av {
-namespace player {
-
-PlayerCore::PlayerCore()
-    : m_eventCallback(nullptr)
-    , m_formatContext(nullptr)
-    , m_volume(1.0)
-    , m_playbackSpeed(1.0)
-    , m_seekTarget(-1)
-    , m_seeking(false)
-    , m_lastUpdateTime(0)
-    , m_initialized(false)
-    , m_state(PlayerState::Idle)
-    , m_frameCount(0)
-{
-    av::Logger::instance().info("PlayerCore created");
-    
-    try {
-        // 初始化FFmpeg
-        if (!initializeFFmpeg()) {
-            av::Logger::instance().error("Failed to initialize FFmpeg");
-            setState(PlayerState::Error);
-            return;
-        }
-        
-        // 创建队列
-        m_packetQueue = av::utils::PacketQueueFactory::createStandardQueue(1000);  // 最多1000个包
-        if (!m_packetQueue) {
-            av::Logger::instance().error("Failed to create packet queue");
-            setState(PlayerState::Error);
-            return;
-        }
-        
-        m_videoFrameQueue = av::utils::FrameQueueFactory::createStandardQueue(30); // 最多30帧
-        if (!m_videoFrameQueue) {
-            av::Logger::instance().error("Failed to create video frame queue");
-            setState(PlayerState::Error);
-            return;
-        }
-        
-        m_audioFrameQueue = av::utils::FrameQueueFactory::createStandardQueue(100); // 最多100帧
-        if (!m_audioFrameQueue) {
-            av::Logger::instance().error("Failed to create audio frame queue");
-            setState(PlayerState::Error);
-            return;
-        }
-        
-        // 创建同步器
-        m_synchronizer = std::make_unique<Synchronizer>();
-        if (!m_synchronizer) {
-            av::Logger::instance().error("Failed to create synchronizer");
-            setState(PlayerState::Error);
-            return;
-        }
-        
-        // 创建线程管理器
-        m_threadManager = std::make_unique<ThreadManager>();
-        if (!m_threadManager) {
-            av::Logger::instance().error("Failed to create thread manager");
-            setState(PlayerState::Error);
-            return;
-        }
-        
-        // 创建解码器
-        m_videoDecoder = std::make_unique<VideoDecoder>();
-        if (!m_videoDecoder) {
-            av::Logger::instance().error("Failed to create video decoder");
-            setState(PlayerState::Error);
-            return;
-        }
-        
-        m_audioDecoder = std::make_unique<AudioDecoder>();
-        if (!m_audioDecoder) {
-            av::Logger::instance().error("Failed to create audio decoder");
-            setState(PlayerState::Error);
-            return;
-        }
-        
-        // 创建音频输出设备
-        m_audioOutput = std::make_unique<AudioOutput>();
-        if (!m_audioOutput) {
-            av::Logger::instance().error("Failed to create audio output");
-            setState(PlayerState::Error);
-            return;
-        }
-        
-        m_initialized = true;
-        av::Logger::instance().info("PlayerCore initialized successfully");
-        
-    } catch (const std::exception& e) {
-        av::Logger::instance().error("Exception during PlayerCore initialization: " + std::string(e.what()));
-        setState(PlayerState::Error);
-        m_initialized = false;
-    } catch (...) {
-        av::Logger::instance().error("Unknown exception during PlayerCore initialization");
-        setState(PlayerState::Error);
-        m_initialized = false;
-    }
-}
-
-PlayerCore::~PlayerCore()
-{
-    av::Logger::instance().info("PlayerCore destroying...");
-    stop();
-    cleanup();
-    av::Logger::instance().info("PlayerCore destroyed");
-}
-
-void PlayerCore::setEventCallback(PlayerEventCallback* callback)
-{
-    std::lock_guard<std::mutex> lock(m_mutex);
-    m_eventCallback = callback;
-}
-
-ErrorCode PlayerCore::openFile(const std::string& filename)
-{
-    av::Logger::instance().info("Opening file: " + filename);
-    
-    if (!m_initialized) {
-        av::Logger::instance().error("PlayerCore not initialized");
-        return ErrorCode::NOT_INITIALIZED;
-    }
-    
-    // 如果正在播放，先停止
-    if (m_state != PlayerState::Idle) {
-        stop();
-    }
-    
-    setState(PlayerState::Opening);
-    
-    // 打开媒体文件
-    if (!openMediaFile(filename)) {
-        setState(PlayerState::Error);
-        notifyError("Failed to open media file: " + filename);
-        return ErrorCode::FILE_OPEN_FAILED;
-    }
-    
-    // 设置媒体信息
-    m_mediaInfo.filename = filename;
-    
-    // 设置解码器
-    if (m_mediaInfo.hasVideo && !setupVideoDecoder()) {
-        av::Logger::instance().error("Failed to setup video decoder");
-        setState(PlayerState::Error);
-        return ErrorCode::CODEC_OPEN_FAILED;
-    }
-    
-    if (m_mediaInfo.hasAudio && !setupAudioDecoder()) {
-        av::Logger::instance().error("Failed to setup audio decoder");
-        setState(PlayerState::Error);
-        return ErrorCode::CODEC_OPEN_FAILED;
-    }
-    
-    setState(PlayerState::Stopped);
-    
-    // 如果已设置视频渲染器且有视频流，重新初始化渲染器
-    if (m_mediaInfo.hasVideo) {
-        AVStream* videoStream = m_formatContext->streams[m_mediaInfo.videoStreamIndex];
-        double fps = m_mediaInfo.fps > 0 ? m_mediaInfo.fps : 25.0; // 使用实际帧率或默认25fps
-        
-        // 初始化OpenGL渲染器
-        if (m_openGLVideoRenderer) {
-            bool rendererInitResult = m_openGLVideoRenderer->initialize(
-                videoStream->codecpar->width,
-                videoStream->codecpar->height,
-                static_cast<AVPixelFormat>(videoStream->codecpar->format),
-                fps
-            );
-            if (!rendererInitResult) {
-                av::Logger::instance().warning("Failed to initialize OpenGL video renderer");
-            } else {
-                av::Logger::instance().info("OpenGL video renderer initialized successfully with fps: " + std::to_string(fps));
-            }
-        }
-    }
-    
-    // 通知媒体信息变化
-    if (m_eventCallback) {
-        m_eventCallback->onMediaInfoChanged(m_mediaInfo);
-    }
-    
-    av::Logger::instance().info("File opened successfully: " + filename);
-    return ErrorCode::SUCCESS;
-}
-
-ErrorCode PlayerCore::play()
-{
-    av::Logger::instance().info("Starting playback");
-    
-    if (m_state == PlayerState::Playing) {
-        av::Logger::instance().debug("Already playing");
-        return ErrorCode::SUCCESS;
-    }
-    
-    if (m_state != PlayerState::Stopped && m_state != PlayerState::Paused) {
-        av::Logger::instance().error("Invalid state for play: " + std::to_string(static_cast<int>(m_state.load())));
-        return ErrorCode::INVALID_STATE;
-    }
-    
-    // 记录播放开始时间
-    m_playStartTime = std::chrono::steady_clock::now();
-    
-    // 如果是从停止状态开始播放，重置基准时间
-    if (m_state == PlayerState::Stopped) {
-        m_baseTime = 0;
-    }
-    // 如果是从暂停状态恢复播放，保持之前的基准时间
-    
-    // 启动音频输出设备 - 在解码线程启动前启动，确保设备准备好
-    if (m_audioOutput && m_mediaInfo.hasAudio) {
-        if (m_state == PlayerState::Paused) {
-            m_audioOutput->resume();
-        } else {
-            m_audioOutput->start();
-        }
-        
-        // 给音频输出设备一点时间完全初始化
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    }
-    
-    // 启动读取线程
-    if (!startReadThread()) {
-        av::Logger::instance().error("Failed to start read thread");
-        return ErrorCode::THREAD_ERROR;
-    }
-    
-    // 启动解码线程
-    if (!startDecodeThreads()) {
-        av::Logger::instance().error("Failed to start decode threads");
-        return ErrorCode::THREAD_ERROR;
-    }
-    
-    setState(PlayerState::Playing);
-    av::Logger::instance().info("Playback started");
-    return ErrorCode::SUCCESS;
-}
-
-ErrorCode PlayerCore::pause()
-{
-    av::Logger::instance().info("Pausing playback");
-    
-    if (m_state != PlayerState::Playing) {
-        av::Logger::instance().debug("Not playing, cannot pause");
-        return ErrorCode::INVALID_STATE;
-    }
-    
-    // 记录暂停时的播放时间
-    if (m_playStartTime.time_since_epoch().count() != 0) {
-        auto currentTime = std::chrono::steady_clock::now();
-        auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(
-            currentTime - m_playStartTime).count();
-        m_baseTime += static_cast<int64_t>(elapsed * m_playbackSpeed);
-        m_playStartTime = std::chrono::steady_clock::time_point{};
-    }
-    
-    // 暂停音频输出
-    if (m_audioOutput) {
-        m_audioOutput->pause();
-    }
-    
-    setState(PlayerState::Paused);
-    av::Logger::instance().info("Playback paused");
-    return ErrorCode::SUCCESS;
-}
-
-ErrorCode PlayerCore::stop()
-{
-    av::Logger::instance().info("Stopping playback");
-    
-    if (m_state == PlayerState::Idle || m_state == PlayerState::Stopped) {
-        av::Logger::instance().debug("Already stopped");
-        return ErrorCode::SUCCESS;
-    }
-    
-    // 停止音频输出
-    if (m_audioOutput) {
-        m_audioOutput->stop();
-    }
-    
-    // 清空OpenGL视频渲染器
-    if (m_openGLVideoRenderer) {
-        m_openGLVideoRenderer->clear();
-    }
-    
-    // 停止所有线程
-    stopAllThreads();
-    
-    // 重置解码器
-    resetDecoders();
-    
-    // 清空队列
-    if (m_packetQueue) m_packetQueue->clear();
-    if (m_videoFrameQueue) m_videoFrameQueue->clear();
-    if (m_audioFrameQueue) m_audioFrameQueue->clear();
-    
-    setState(PlayerState::Stopped);
-    av::Logger::instance().info("Playback stopped");
-    return ErrorCode::SUCCESS;
-}
-
-ErrorCode PlayerCore::seek(int64_t timestamp)
-{
-    av::Logger::instance().info("Seeking to: " + std::to_string(timestamp));
-    
-    if (m_state == PlayerState::Idle || m_state == PlayerState::Opening) {
-        av::Logger::instance().error("Invalid state for seek");
-        return ErrorCode::INVALID_STATE;
-    }
-    
-    std::lock_guard<std::mutex> lock(m_mutex);
-    m_seekTarget = timestamp;
-    m_seeking = true;
-    
-    // 更新基准时间为跳转目标时间
-    m_baseTime = timestamp;
-    m_playStartTime = std::chrono::steady_clock::now();
-    
-    // 清空队列
-    if (m_packetQueue) m_packetQueue->clear();
-    if (m_videoFrameQueue) m_videoFrameQueue->clear();
-    if (m_audioFrameQueue) m_audioFrameQueue->clear();
-    
-    setState(PlayerState::Seeking);
-    av::Logger::instance().info("Seek initiated");
-    return ErrorCode::SUCCESS;
-}
-
-ErrorCode PlayerCore::setPlaybackSpeed(double speed)
-{
-    if (speed <= 0.0 || speed > 4.0) {
-        av::Logger::instance().error("Invalid playback speed: " + std::to_string(speed));
-        return ErrorCode::INVALID_PARAMS;
-    }
-    
-    std::lock_guard<std::mutex> lock(m_mutex);
-    m_playbackSpeed = speed;
-    
-    // 设置同步器的播放速度
-    if (m_synchronizer) {
-        m_synchronizer->setPlaybackSpeed(speed);
-    }
-    
-    // 设置音频输出的播放速度
-    if (m_audioOutput) {
-        m_audioOutput->setPlaybackSpeed(speed);
-    }
-    
-    av::Logger::instance().info("Playback speed set to: " + std::to_string(speed));
-    return ErrorCode::SUCCESS;
-}
-
-MediaInfo PlayerCore::getMediaInfo() const
-{
-    std::lock_guard<std::mutex> lock(m_mutex);
-    return m_mediaInfo;
-}
-
-PlaybackStats PlayerCore::getStats() const
-{
-    std::lock_guard<std::mutex> lock(m_mutex);
-    return m_stats;
-}
-
-int64_t PlayerCore::getCurrentTime() const
-{
-    std::lock_guard<std::mutex> lock(m_mutex);
-    return m_stats.currentTime;
-}
-
-double PlayerCore::getPlaybackSpeed() const
-{
-    std::lock_guard<std::mutex> lock(m_mutex);
-    return m_playbackSpeed;
-}
-
-void PlayerCore::setVolume(double volume)
-{
-    volume = std::max(0.0, std::min(1.0, volume));
-    std::lock_guard<std::mutex> lock(m_mutex);
-    m_volume = volume;
-    
-    // 同时设置音频输出设备的音量
-    if (m_audioOutput) {
-        m_audioOutput->setVolume(volume);
-    }
-    
-    av::Logger::instance().debug("Volume set to: " + std::to_string(volume));
-}
-
-AVFrame* PlayerCore::getNextVideoFrame()
-{
-    if (m_videoFrameQueue) {
-        return m_videoFrameQueue->dequeueFrame(1);
-    }
-    return nullptr;
-}
-
-AVFrame* PlayerCore::getNextAudioFrame()
-{
-    if (m_audioFrameQueue) {
-        return m_audioFrameQueue->dequeueFrame(1);
-    }
-    return nullptr;
-}
-
-void PlayerCore::releaseVideoFrame(AVFrame* frame)
-{
-    if (frame) {
-        av_frame_free(&frame);
-    }
-}
-
-void PlayerCore::releaseAudioFrame(AVFrame* frame)
-{
-    if (frame) {
-        av_frame_free(&frame);
-    }
-}
-
-void PlayerCore::update()
-{
-    // 更新统计信息
-    updateStats();
-    
-    // 处理跳转
-    if (m_seeking.load()) {
-        // 跳转逻辑
-        // TODO: 实现跳转处理
-        m_seeking = false;
-        setState(PlayerState::Playing);
-    }
-    
-    // 检查是否播放结束
-    if (m_state == PlayerState::Playing) {
-        // TODO: 检查EOF条件
-    }
-}
-
-bool PlayerCore::initializeFFmpeg()
-{
-    static bool initialized = false;
-    if (!initialized) {
-        av_log_set_level(AV_LOG_INFO);
-        initialized = true;
-        av::Logger::instance().info("FFmpeg initialized");
-    }
-    return true;
-}
-
-void PlayerCore::cleanup()
-{
-    stopAllThreads();
-    closeMediaFile();
-    resetDecoders();
-}
-
-bool PlayerCore::openMediaFile(const std::string& filename)
-{
-    // 打开输入文件
-    int ret = avformat_open_input(&m_formatContext, filename.c_str(), nullptr, nullptr);
-    if (ret < 0) {
-        av::Logger::instance().error("Could not open input file: " + filename);
-        return false;
-    }
-    
-    // 查找流信息
-    ret = avformat_find_stream_info(m_formatContext, nullptr);
-    if (ret < 0) {
-        av::Logger::instance().error("Could not find stream information");
-        return false;
-    }
-    
-    // 分析流信息
-    m_mediaInfo.duration = m_formatContext->duration;
-    
-    for (unsigned int i = 0; i < m_formatContext->nb_streams; i++) {
-        AVStream* stream = m_formatContext->streams[i];
-        AVCodecParameters* codecpar = stream->codecpar;
-        
-        if (codecpar->codec_type == AVMEDIA_TYPE_VIDEO && m_mediaInfo.videoStreamIndex == -1) {
-            m_mediaInfo.videoStreamIndex = i;
-            m_mediaInfo.hasVideo = true;
-            m_mediaInfo.width = codecpar->width;
-            m_mediaInfo.height = codecpar->height;
-            m_mediaInfo.fps = av_q2d(stream->avg_frame_rate);
-        }
-        else if (codecpar->codec_type == AVMEDIA_TYPE_AUDIO && m_mediaInfo.audioStreamIndex == -1) {
-            m_mediaInfo.audioStreamIndex = i;
-            m_mediaInfo.hasAudio = true;
-            m_mediaInfo.audioSampleRate = codecpar->sample_rate;
-            m_mediaInfo.audioChannels = codecpar->ch_layout.nb_channels;
-        }
-        else if (codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE && m_mediaInfo.subtitleStreamIndex == -1) {
-            m_mediaInfo.subtitleStreamIndex = i;
-            m_mediaInfo.hasSubtitle = true;
-        }
-    }
-    
-    av::Logger::instance().info("Media file opened successfully");
-    av::Logger::instance().info("Duration: " + std::to_string(m_mediaInfo.duration));
-    av::Logger::instance().info("Has video: " + std::to_string(m_mediaInfo.hasVideo));
-    av::Logger::instance().info("Has audio: " + std::to_string(m_mediaInfo.hasAudio));
-    
-    return true;
-}
-
-void PlayerCore::closeMediaFile()
-{
-    if (m_formatContext) {
-        avformat_close_input(&m_formatContext);
-        m_formatContext = nullptr;
-    av::Logger::instance().info("Media file closed");
-    }
-}
-
-bool PlayerCore::startReadThread()
-{
-    if (!m_threadManager) {
-        m_threadManager = std::make_unique<ThreadManager>();
-    }
-    
-    return m_threadManager->createReadThread(
-        m_formatContext,
-        m_packetQueue.get(),
-        m_mediaInfo.videoStreamIndex,
-        m_mediaInfo.audioStreamIndex
-    );
-}
-
-bool PlayerCore::startDecodeThreads()
-{
-    if (!m_threadManager) {
-        m_threadManager = std::make_unique<ThreadManager>();
-    }
-    
-    bool success = true;
-    
-    if (m_mediaInfo.hasVideo) {
-        AVStream* videoStream = m_formatContext->streams[m_mediaInfo.videoStreamIndex];
-        success &= m_threadManager->createVideoDecodeThread(
-            m_packetQueue.get(),
-            m_videoFrameQueue.get(),
-            m_videoDecoder.get(),
-            m_synchronizer.get(),
-            m_mediaInfo.videoStreamIndex,
-            videoStream->codecpar,
-            videoStream->time_base
-        );
-        
-        // 设置视频帧输出回调
-        if (success && m_threadManager->getVideoDecodeThread()) {
-            m_threadManager->getVideoDecodeThread()->setFrameOutputCallback(
-                [this](const AVFramePtr& frame) {
-                    if (frame && m_state == PlayerState::Playing) {
-                        // 使用OpenGL渲染器
-                        if (m_openGLVideoRenderer) {
-                            m_openGLVideoRenderer->renderFrame(frame);
-                        }
-                    }
-                }
-            );
-        }
-    }
-    
-    if (m_mediaInfo.hasAudio) {
-        AVStream* audioStream = m_formatContext->streams[m_mediaInfo.audioStreamIndex];
-        success &= m_threadManager->createAudioDecodeThread(
-            m_packetQueue.get(),
-            m_audioFrameQueue.get(),
-            m_audioDecoder.get(),
-            m_synchronizer.get(),
-            m_mediaInfo.audioStreamIndex,
-            audioStream->time_base
-        );
-        
-        // 设置音频帧输出回调
-        if (success && m_threadManager->getAudioDecodeThread()) {
-            m_threadManager->getAudioDecodeThread()->setFrameOutputCallback(
-                [this](const AVFramePtr& frame) {
-                    if (m_audioOutput && frame && m_state == PlayerState::Playing) {
-                        m_audioOutput->writeFrame(frame);
-                    }
-                }
-            );
-        }
-    }
-    
-    if (success) {
-        success = m_threadManager->startAll();
-    }
-    
-    return success;
-}
-
-void PlayerCore::stopAllThreads()
-{
-    if (m_threadManager) {
-        m_threadManager->stopAll();
-        m_threadManager.reset();
-    }
-    av::Logger::instance().info("All threads stopped");
-}
-
-void PlayerCore::readThreadFunc()
-{
-    // 读取线程实现
-    while (m_state != PlayerState::Stopped && m_state != PlayerState::Error) {
-        if (m_state == PlayerState::Paused) {
-            std::this_thread::sleep_for(std::chrono::milliseconds(10));
-            continue;
-        }
-        
-        AVPacket* packet = av_packet_alloc();
-        if (!packet) {
-            break;
-        }
-        
-        int ret = av_read_frame(m_formatContext, packet);
-        if (ret < 0) {
-            av_packet_free(&packet);
-            if (ret == AVERROR_EOF) {
-                // 文件结束
-                if (m_eventCallback) {
-                    m_eventCallback->onEndOfFile();
-                }
-            }
-            break;
-        }
-        
-        // 将数据包放入队列
-        if (m_packetQueue) {
-            if (m_packetQueue->enqueue(packet) != av::ErrorCode::SUCCESS) {
-                av_packet_free(&packet);
-            }
-        } else {
-            av_packet_free(&packet);
-        }
-    }
-}
-
-
-
-bool PlayerCore::setupVideoDecoder()
-{
-    if (!m_mediaInfo.hasVideo) {
-        return true;
-    }
-    
-    AVStream* videoStream = m_formatContext->streams[m_mediaInfo.videoStreamIndex];
-    const AVCodec* codec = avcodec_find_decoder(videoStream->codecpar->codec_id);
-    
-    if (!codec) {
-        av::Logger::instance().error("Video codec not found");
-        return false;
-    }
-    
-    // 创建视频解码器
-    m_videoDecoder = std::make_unique<VideoDecoder>();
-    
-    av::codec::VideoDecoderParams params;
-    params.codecName = codec->name;
-    params.width = videoStream->codecpar->width;
-    params.height = videoStream->codecpar->height;
-    params.pixelFormat = static_cast<AVPixelFormat>(videoStream->codecpar->format);
-    params.hardwareAccel = false; // 默认软件解码
-    params.threadCount = 4;
-    
-    ErrorCode result = m_videoDecoder->open(params);
-    if (result != ErrorCode::SUCCESS) {
-        av::Logger::instance().error("Failed to open video decoder");
-        return false;
-    }
-    
-    av::Logger::instance().info("Video decoder setup successfully");
-    return true;
-}
-
-bool PlayerCore::setupAudioDecoder()
-{
-    if (!m_mediaInfo.hasAudio) {
-        return true;
-    }
-    
-    AVStream* audioStream = m_formatContext->streams[m_mediaInfo.audioStreamIndex];
-    const AVCodec* codec = avcodec_find_decoder(audioStream->codecpar->codec_id);
-    
-    if (!codec) {
-        av::Logger::instance().error("Audio codec not found");
-        return false;
-    }
-    
-    // 创建音频解码器
-    m_audioDecoder = std::make_unique<AudioDecoder>();
-    
-    av::codec::AudioDecoderParams params;
-    params.codecName = codec->name;
-    params.sampleRate = audioStream->codecpar->sample_rate;
-    params.channels = audioStream->codecpar->ch_layout.nb_channels;
-    params.sampleFormat = static_cast<AVSampleFormat>(audioStream->codecpar->format);
-    params.enableResampling = true;
-    
-    ErrorCode result = m_audioDecoder->open(params);
-    if (result != ErrorCode::SUCCESS) {
-        av::Logger::instance().error("Failed to open audio decoder");
-        return false;
-    }
-    
-    // 初始化音频输出设备
-    if (m_audioOutput) {
-        bool audioInitResult = m_audioOutput->initialize(
-            audioStream->codecpar->sample_rate,
-            audioStream->codecpar->ch_layout.nb_channels,
-            static_cast<AVSampleFormat>(audioStream->codecpar->format)
-        );
-        if (!audioInitResult) {
-            av::Logger::instance().error("Failed to initialize audio output");
-            return false;
-        }
-    }
-    
-    av::Logger::instance().info("Audio decoder setup successfully");
-    return true;
-}
-
-void PlayerCore::resetDecoders()
-{
-    if (m_videoDecoder) {
-        m_videoDecoder->close();
-        m_videoDecoder.reset();
-    }
-    
-    if (m_audioDecoder) {
-        m_audioDecoder->close();
-        m_audioDecoder.reset();
-    }
-    
-    av::Logger::instance().info("Decoders reset");
-}
-
-void PlayerCore::updateSynchronization()
-{
-    // TODO: 实现同步逻辑
-}
-
-int64_t PlayerCore::getCurrentPlayTime()
-{
-    if (m_state == PlayerState::Idle || m_state == PlayerState::Stopped) {
-        return 0;
-    }
-    
-    // 使用系统时间计算播放时间
-    auto currentTime = std::chrono::steady_clock::now();
-    if (m_playStartTime.time_since_epoch().count() == 0) {
-        return 0;
-    }
-    
-    auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(
-        currentTime - m_playStartTime).count();
-    
-    // 考虑播放速度
-    elapsed = static_cast<int64_t>(elapsed * m_playbackSpeed);
-    
-    return m_baseTime + elapsed;
-}
-
-void PlayerCore::setState(PlayerState newState)
-{
-    PlayerState oldState = m_state.exchange(newState);
-    if (oldState != newState) {
-        av::Logger::instance().debug("State changed: " + std::to_string(static_cast<int>(oldState)) + 
-                 " -> " + std::to_string(static_cast<int>(newState)));
-        notifyStateChanged(newState);
-    }
-}
-
-void PlayerCore::updateStats()
-{
-    std::lock_guard<std::mutex> lock(m_mutex);
-    
-    // 更新队列统计
-    if (m_packetQueue) {
-        m_stats.queuedPackets = m_packetQueue->size();
-    }
-    if (m_videoFrameQueue) {
-        m_stats.queuedVideoFrames = m_videoFrameQueue->size();
-    }
-    if (m_audioFrameQueue) {
-        m_stats.queuedAudioFrames = m_audioFrameQueue->size();
-    }
-    
-    m_stats.playbackSpeed = m_playbackSpeed;
-    m_stats.currentTime = getCurrentPlayTime();
-}
-
-void PlayerCore::notifyStateChanged(PlayerState newState)
-{
-    if (m_eventCallback) {
-        m_eventCallback->onStateChanged(newState);
-    }
-}
-
-void PlayerCore::notifyError(const std::string& error)
-{
-    if (m_eventCallback) {
-        m_eventCallback->onErrorOccurred(error);
-    }
-}
-
-
-
-void PlayerCore::setOpenGLVideoRenderer(OpenGLVideoRenderer* renderer)
-{
-    std::lock_guard<std::mutex> lock(m_mutex);
-    m_openGLVideoRenderer = renderer;
-    
-    // 如果已有媒体信息且OpenGL视频渲染器可用，初始化渲染器
-    if (m_openGLVideoRenderer && m_mediaInfo.hasVideo) {
-        AVStream* videoStream = m_formatContext->streams[m_mediaInfo.videoStreamIndex];
-        double fps = m_mediaInfo.fps > 0 ? m_mediaInfo.fps : 25.0; // 使用实际帧率或默认25fps
-        m_openGLVideoRenderer->initialize(
-            videoStream->codecpar->width,
-            videoStream->codecpar->height,
-            static_cast<AVPixelFormat>(videoStream->codecpar->format),
-            fps
-        );
-    }
-    
-    av::Logger::instance().info("OpenGL video renderer set");
-}
-
-} // namespace player
-} // namespace av

AV/code/player/player_core_v2.cpp

@@ -0,0 +1,1447 @@
+#include "player_core_v2.h"
+#include "../base/media_common.h"
+#include "../base/logger.h"
+#include "../base/types.h"
+#include "../codec/codec_video_decoder.h"
+#include "../codec/codec_audio_decoder.h"
+#include "../utils/utils_synchronizer_v2.h"
+#include <chrono>
+#include <thread>
+#include <algorithm>
+
+#ifdef _WIN32
+#include <windows.h>
+#include <psapi.h>
+#else
+#include <sys/times.h>
+#include <unistd.h>
+#endif
+
+namespace av {
+namespace player {
+
+PlayerCoreV2::PlayerCoreV2(const SyncConfigV2& syncConfig)
+    : m_eventCallback(nullptr)
+    , m_formatContext(nullptr)
+    , m_openGLVideoRenderer(nullptr)
+    , m_volume(1.0)
+    , m_playbackSpeed(1.0)
+    , m_seekTarget(-1)
+    , m_seeking(false)
+    , m_baseTime(0)
+    , m_lastUpdateTime(0)
+    , m_threadsShouldStop(false)
+    , m_threadsRunning(false)
+    , m_initialized(false)
+    , m_frameCount(0)
+    , m_lastFrameCount(0)
+    , m_errorCount(0)
+    , m_buffering(false)
+    , m_bufferHealth(1.0)
+    , m_state(PlayerState::Idle) {
+    
+    Logger::instance().info("PlayerCoreV2 created");
+    
+    try {
+        // 初始化FFmpeg
+        if (!initializeFFmpeg()) {
+            Logger::instance().error("Failed to initialize FFmpeg");
+            setState(PlayerState::Error);
+            return;
+        }
+        
+        // 创建队列
+        m_packetQueue = av::utils::PacketQueueFactory::createStandardQueue(2000);  // 增加队列大小
+        if (!m_packetQueue) {
+            Logger::instance().error("Failed to create packet queue");
+            setState(PlayerState::Error);
+            return;
+        }
+        
+        m_videoFrameQueue = av::utils::FrameQueueFactory::createStandardQueue(50); // 增加视频帧队列
+        if (!m_videoFrameQueue) {
+            Logger::instance().error("Failed to create video frame queue");
+            setState(PlayerState::Error);
+            return;
+        }
+        
+        m_audioFrameQueue = av::utils::FrameQueueFactory::createStandardQueue(200); // 增加音频帧队列
+        if (!m_audioFrameQueue) {
+            Logger::instance().error("Failed to create audio frame queue");
+            setState(PlayerState::Error);
+            return;
+        }
+        
+        // 创建改进的同步器
+        m_synchronizer = std::make_unique<SynchronizerV2>(syncConfig);
+        if (!m_synchronizer) {
+            Logger::instance().error("Failed to create synchronizer");
+            setState(PlayerState::Error);
+            return;
+        }
+        
+        // 设置同步器回调
+        m_synchronizer->setSyncErrorCallback([this](double error, const std::string& reason) {
+            handleSyncError(error, reason);
+        });
+        
+        m_synchronizer->setFrameDropCallback([this](av::utils::ClockType type, double pts) {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            m_stats.droppedFrames++;
+            if (m_eventCallback) {
+                m_eventCallback->onFrameDropped(m_stats.droppedFrames);
+            }
+        });
+        
+        // 创建线程管理器
+        m_threadManager = std::make_unique<ThreadManager>();
+        if (!m_threadManager) {
+            Logger::instance().error("Failed to create thread manager");
+            setState(PlayerState::Error);
+            return;
+        }
+        
+        // 创建解码器
+        m_videoDecoder = std::make_unique<VideoDecoder>();
+        if (!m_videoDecoder) {
+            Logger::instance().error("Failed to create video decoder");
+            setState(PlayerState::Error);
+            return;
+        }
+        
+        m_audioDecoder = std::make_unique<AudioDecoder>();
+        if (!m_audioDecoder) {
+            Logger::instance().error("Failed to create audio decoder");
+            setState(PlayerState::Error);
+            return;
+        }
+        
+        // 创建音频输出设备
+        m_audioOutput = std::make_unique<AudioOutput>();
+        if (!m_audioOutput) {
+            Logger::instance().error("Failed to create audio output");
+            setState(PlayerState::Error);
+            return;
+        }
+        
+        // 初始化性能监控
+        m_lastStatsUpdate = std::chrono::steady_clock::now();
+        m_lastCpuMeasure = m_lastStatsUpdate;
+#ifdef _WIN32
+        m_lastCpuTime = GetTickCount64();
+#else
+        struct tms tm;
+        m_lastCpuTime = times(&tm);
+#endif
+        
+        m_initialized = true;
+        Logger::instance().info("PlayerCoreV2 initialized successfully");
+        
+    } catch (const std::exception& e) {
+        Logger::instance().error("Exception during PlayerCoreV2 initialization: " + std::string(e.what()));
+        setState(PlayerState::Error);
+        m_initialized = false;
+    } catch (...) {
+        Logger::instance().error("Unknown exception during PlayerCoreV2 initialization");
+        setState(PlayerState::Error);
+        m_initialized = false;
+    }
+}
+
+PlayerCoreV2::~PlayerCoreV2() {
+    Logger::instance().info("PlayerCoreV2 destroying...");
+    stop();
+    cleanup();
+    Logger::instance().info("PlayerCoreV2 destroyed");
+}
+
+void PlayerCoreV2::setEventCallback(PlayerEventCallback* callback) {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    m_eventCallback = callback;
+}
+
+ErrorCode PlayerCoreV2::openFile(const std::string& filename) {
+    Logger::instance().info("Opening file: " + filename);
+    
+    if (!m_initialized) {
+        Logger::instance().error("PlayerCoreV2 not initialized");
+        return ErrorCode::NOT_INITIALIZED;
+    }
+    
+    // 如果正在播放，先停止
+    if (m_state != PlayerState::Idle) {
+        stop();
+    }
+    
+    setState(PlayerState::Opening);
+    
+    // 打开媒体文件
+    if (!openMediaFile(filename)) {
+        setState(PlayerState::Error);
+        notifyError("Failed to open media file: " + filename);
+        return ErrorCode::FILE_OPEN_FAILED;
+    }
+    
+    // 设置媒体信息
+    m_mediaInfo.filename = filename;
+    
+    // 设置解码器
+    if (m_mediaInfo.hasVideo && !setupVideoDecoder()) {
+        Logger::instance().error("Failed to setup video decoder");
+        setState(PlayerState::Error);
+        return ErrorCode::CODEC_OPEN_FAILED;
+    }
+    
+    if (m_mediaInfo.hasAudio && !setupAudioDecoder()) {
+        Logger::instance().error("Failed to setup audio decoder");
+        setState(PlayerState::Error);
+        return ErrorCode::CODEC_OPEN_FAILED;
+    }
+    
+    // 初始化同步器
+    if (m_synchronizer->initialize() != ErrorCode::SUCCESS) {
+        Logger::instance().error("Failed to initialize synchronizer");
+        setState(PlayerState::Error);
+        return ErrorCode::SYNC_ERROR;
+    }
+    
+    setState(PlayerState::Stopped);
+    
+    // 如果已设置视频渲染器且有视频流，重新初始化渲染器
+    if (m_mediaInfo.hasVideo && m_openGLVideoRenderer) {
+        AVStream* videoStream = m_formatContext->streams[m_mediaInfo.videoStreamIndex];
+        double fps = m_mediaInfo.fps > 0 ? m_mediaInfo.fps : 25.0;
+        
+        bool rendererInitResult = m_openGLVideoRenderer->initialize(
+            videoStream->codecpar->width,
+            videoStream->codecpar->height,
+            static_cast<AVPixelFormat>(videoStream->codecpar->format),
+            fps
+        );
+        
+        if (!rendererInitResult) {
+            Logger::instance().warning("Failed to initialize OpenGL video renderer");
+        } else {
+            Logger::instance().info("OpenGL video renderer initialized successfully with fps: " + std::to_string(fps));
+        }
+    }
+    
+    // 通知媒体信息变化
+    if (m_eventCallback) {
+        m_eventCallback->onMediaInfoChanged(m_mediaInfo);
+    }
+    
+    Logger::instance().info("File opened successfully: " + filename);
+    return ErrorCode::SUCCESS;
+}
+
+ErrorCode PlayerCoreV2::play() {
+    Logger::instance().info("Starting playback");
+    
+    if (m_state == PlayerState::Playing) {
+        Logger::instance().debug("Already playing");
+        return ErrorCode::SUCCESS;
+    }
+    
+    if (m_state != PlayerState::Stopped && m_state != PlayerState::Paused) {
+        Logger::instance().error("Invalid state for play: " + std::to_string(static_cast<int>(m_state.load())));
+        return ErrorCode::INVALID_STATE;
+    }
+    
+    // 启动同步器
+    if (m_synchronizer->start() != ErrorCode::SUCCESS) {
+        Logger::instance().error("Failed to start synchronizer");
+        return ErrorCode::SYNC_ERROR;
+    }
+    
+    // 记录播放开始时间
+    m_playStartTime = std::chrono::steady_clock::now();
+    
+    // 如果是从停止状态开始播放，重置基准时间
+    if (m_state == PlayerState::Stopped) {
+        m_baseTime = 0;
+        m_frameCount = 0;
+        m_lastFrameCount = 0;
+        
+        // 重置统计信息
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_stats = PlaybackStats();
+        m_stats.playbackSpeed = m_playbackSpeed;
+    }
+    
+    // 启动音频输出设备
+    if (m_audioOutput && m_mediaInfo.hasAudio) {
+        if (m_state == PlayerState::Paused) {
+            m_audioOutput->resume();
+        } else {
+            m_audioOutput->start();
+        }
+        
+        // 设置音频参数
+        m_audioOutput->setVolume(m_volume);
+        m_audioOutput->setPlaybackSpeed(m_playbackSpeed);
+        
+        // 给音频输出设备时间初始化
+        std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    }
+    
+    // 启动线程
+    m_threadsShouldStop = false;
+    
+    if (!startReadThread()) {
+        Logger::instance().error("Failed to start read thread");
+        return ErrorCode::THREAD_ERROR;
+    }
+    
+    if (!startDecodeThreads()) {
+        Logger::instance().error("Failed to start decode threads");
+        return ErrorCode::THREAD_ERROR;
+    }
+    
+    if (m_mediaInfo.hasVideo && !startVideoPlayThread()) {
+        Logger::instance().error("Failed to start video play thread");
+        return ErrorCode::THREAD_ERROR;
+    }
+    
+    if (m_mediaInfo.hasAudio && !startAudioPlayThread()) {
+        Logger::instance().error("Failed to start audio play thread");
+        return ErrorCode::THREAD_ERROR;
+    }
+    
+    m_threadsRunning = true;
+    setState(PlayerState::Playing);
+    
+    Logger::instance().info("Playback started");
+    return ErrorCode::SUCCESS;
+}
+
+ErrorCode PlayerCoreV2::pause() {
+    Logger::instance().info("Pausing playback");
+    
+    if (m_state != PlayerState::Playing) {
+        Logger::instance().debug("Not playing, cannot pause");
+        return ErrorCode::INVALID_STATE;
+    }
+    
+    // 暂停同步器
+    if (m_synchronizer->pause() != ErrorCode::SUCCESS) {
+        Logger::instance().warning("Failed to pause synchronizer");
+    }
+    
+    // 记录暂停时的播放时间
+    if (m_playStartTime.time_since_epoch().count() != 0) {
+        auto currentTime = std::chrono::steady_clock::now();
+        auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(
+            currentTime - m_playStartTime).count();
+        m_baseTime += static_cast<int64_t>(elapsed * m_playbackSpeed);
+        m_playStartTime = std::chrono::steady_clock::time_point{};
+    }
+    
+    // 暂停音频输出
+    if (m_audioOutput) {
+        m_audioOutput->pause();
+    }
+    
+    setState(PlayerState::Paused);
+    Logger::instance().info("Playback paused");
+    return ErrorCode::SUCCESS;
+}
+
+ErrorCode PlayerCoreV2::stop() {
+    Logger::instance().info("Stopping playback");
+    
+    if (m_state == PlayerState::Idle || m_state == PlayerState::Stopped) {
+        Logger::instance().debug("Already stopped");
+        return ErrorCode::SUCCESS;
+    }
+    
+    // 停止同步器
+    if (m_synchronizer) {
+        m_synchronizer->stop();
+    }
+    
+    // 停止音频输出
+    if (m_audioOutput) {
+        m_audioOutput->stop();
+    }
+    
+    // 清空OpenGL视频渲染器
+    if (m_openGLVideoRenderer) {
+        m_openGLVideoRenderer->clear();
+    }
+    
+    // 停止所有线程
+    stopAllThreads();
+    
+    // 重置解码器
+    resetDecoders();
+    
+    // 清空队列
+    if (m_packetQueue) m_packetQueue->clear();
+    if (m_videoFrameQueue) m_videoFrameQueue->clear();
+    if (m_audioFrameQueue) m_audioFrameQueue->clear();
+    
+    // 重置时间
+    m_baseTime = 0;
+    m_playStartTime = std::chrono::steady_clock::time_point{};
+    
+    setState(PlayerState::Stopped);
+    Logger::instance().info("Playback stopped");
+    return ErrorCode::SUCCESS;
+}
+
+ErrorCode PlayerCoreV2::seek(int64_t timestamp) {
+    Logger::instance().info("Seeking to: " + std::to_string(timestamp));
+    
+    if (m_state == PlayerState::Idle || m_state == PlayerState::Opening) {
+        Logger::instance().error("Invalid state for seek");
+        return ErrorCode::INVALID_STATE;
+    }
+    
+    std::unique_lock<std::mutex> lock(m_seekMutex);
+    
+    // 设置seek目标
+    m_seekTarget = timestamp;
+    m_seeking = true;
+    
+    // 更新基准时间为跳转目标时间
+    m_baseTime = timestamp;
+    m_playStartTime = std::chrono::steady_clock::now();
+    
+    // 重置同步器
+    if (m_synchronizer) {
+        m_synchronizer->reset();
+    }
+    
+    // 清空队列
+    flushBuffers();
+    
+    setState(PlayerState::Seeking);
+    
+    // 通知seek条件
+    m_seekCondition.notify_all();
+    
+    Logger::instance().info("Seek initiated");
+    return ErrorCode::SUCCESS;
+}
+
+ErrorCode PlayerCoreV2::setPlaybackSpeed(double speed) {
+    if (speed <= 0.0 || speed > 4.0) {
+        Logger::instance().error("Invalid playback speed: " + std::to_string(speed));
+        return ErrorCode::INVALID_PARAMS;
+    }
+    
+    std::lock_guard<std::mutex> lock(m_mutex);
+    m_playbackSpeed = speed;
+    
+    // 设置同步器的播放速度
+    if (m_synchronizer) {
+        m_synchronizer->setPlaybackSpeed(speed);
+    }
+    
+    // 设置音频输出的播放速度
+    if (m_audioOutput) {
+        m_audioOutput->setPlaybackSpeed(speed);
+    }
+    
+    // 更新统计信息
+    m_stats.playbackSpeed = speed;
+    
+    Logger::instance().info("Playback speed set to: " + std::to_string(speed));
+    return ErrorCode::SUCCESS;
+}
+
+MediaInfo PlayerCoreV2::getMediaInfo() const {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    return m_mediaInfo;
+}
+
+PlaybackStats PlayerCoreV2::getStats() const {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    PlaybackStats stats = m_stats;
+    
+    // 更新当前时间
+    stats.currentTime = getCurrentTime();
+    
+    // 更新队列大小
+    if (m_packetQueue) stats.queuedPackets = m_packetQueue->size();
+    if (m_videoFrameQueue) stats.queuedVideoFrames = m_videoFrameQueue->size();
+    if (m_audioFrameQueue) stats.queuedAudioFrames = m_audioFrameQueue->size();
+    
+    // 更新同步统计
+    if (m_synchronizer) {
+        auto syncStats = m_synchronizer->getStats();
+        stats.syncError = syncStats.syncError;
+        stats.avgSyncError = syncStats.avgSyncError;
+        stats.maxSyncError = syncStats.maxSyncError;
+        stats.droppedFrames = syncStats.droppedFrames;
+        stats.duplicatedFrames = syncStats.duplicatedFrames;
+    }
+    
+    return stats;
+}
+
+int64_t PlayerCoreV2::getCurrentTime() const {
+    if (m_state == PlayerState::Idle || m_state == PlayerState::Stopped) {
+        return 0;
+    }
+    
+    if (m_state == PlayerState::Paused) {
+        return m_baseTime;
+    }
+    
+    if (m_playStartTime.time_since_epoch().count() == 0) {
+        return m_baseTime;
+    }
+    
+    auto currentTime = std::chrono::steady_clock::now();
+    auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(
+        currentTime - m_playStartTime).count();
+    
+    return m_baseTime + static_cast<int64_t>(elapsed * m_playbackSpeed);
+}
+
+double PlayerCoreV2::getPlaybackSpeed() const {
+    return m_playbackSpeed;
+}
+
+void PlayerCoreV2::setVolume(double volume) {
+    volume = std::max(0.0, std::min(1.0, volume));
+    m_volume = volume;
+    
+    // 同时设置音频输出设备的音量
+    if (m_audioOutput) {
+        m_audioOutput->setVolume(volume);
+    }
+    
+    Logger::instance().debug("Volume set to: " + std::to_string(volume));
+}
+
+void PlayerCoreV2::setSyncConfig(const SyncConfigV2& config) {
+    if (m_synchronizer) {
+        m_synchronizer->setConfig(config);
+    }
+}
+
+SyncConfigV2 PlayerCoreV2::getSyncConfig() const {
+    if (m_synchronizer) {
+        return m_synchronizer->getConfig();
+    }
+    return SyncConfigV2();
+}
+
+void PlayerCoreV2::setOpenGLVideoRenderer(OpenGLVideoRenderer* renderer) {
+    m_openGLVideoRenderer = renderer;
+}
+
+AVFrame* PlayerCoreV2::getNextVideoFrame() {
+    if (!m_videoFrameQueue || m_state != PlayerState::Playing) {
+        return nullptr;
+    }
+    
+    return m_videoFrameQueue->pop();
+}
+
+AVFrame* PlayerCoreV2::getNextAudioFrame() {
+    if (!m_audioFrameQueue || m_state != PlayerState::Playing) {
+        return nullptr;
+    }
+    
+    return m_audioFrameQueue->pop();
+}
+
+void PlayerCoreV2::releaseVideoFrame(AVFrame* frame) {
+    if (frame) {
+        av_frame_free(&frame);
+    }
+}
+
+void PlayerCoreV2::releaseAudioFrame(AVFrame* frame) {
+    if (frame) {
+        av_frame_free(&frame);
+    }
+}
+
+void PlayerCoreV2::update() {
+    if (!m_initialized) {
+        return;
+    }
+    
+    // 更新同步状态
+    updateSynchronization();
+    
+    // 更新统计信息
+    auto now = std::chrono::steady_clock::now();
+    if (std::chrono::duration_cast<std::chrono::milliseconds>(now - m_lastStatsUpdate).count() > 500) {
+        updateStats();
+        updatePerformanceStats();
+        m_lastStatsUpdate = now;
+        
+        // 通知位置变化
+        notifyPositionChanged();
+    }
+    
+    // 检查错误恢复
+    if (m_errorCount > 0) {
+        auto timeSinceError = std::chrono::duration_cast<std::chrono::seconds>(now - m_lastErrorTime).count();
+        if (timeSinceError > 5) { // 5秒后重置错误计数
+            m_errorCount = 0;
+        }
+    }
+}
+
+std::string PlayerCoreV2::getDebugInfo() const {
+    std::ostringstream oss;
+    
+    oss << "PlayerCoreV2 Debug Info:\n";
+    oss << "  State: " << static_cast<int>(m_state.load()) << "\n";
+    oss << "  Initialized: " << (m_initialized ? "Yes" : "No") << "\n";
+    oss << "  Threads Running: " << (m_threadsRunning ? "Yes" : "No") << "\n";
+    oss << "  Current Time: " << getCurrentTime() << " us\n";
+    oss << "  Playback Speed: " << m_playbackSpeed << "x\n";
+    oss << "  Volume: " << m_volume << "\n";
+    oss << "  Error Count: " << m_errorCount << "\n";
+    
+    if (m_synchronizer) {
+        oss << "\n" << m_synchronizer->getDebugInfo();
+    }
+    
+    return oss.str();
+}
+
+void PlayerCoreV2::dumpStats() const {
+    PlaybackStats stats = getStats();
+    
+    Logger::instance().info("=== PlayerCoreV2 Statistics ===");
+    Logger::instance().info("Current Time: " + std::to_string(stats.currentTime) + " us");
+    Logger::instance().info("Total Frames: " + std::to_string(stats.totalFrames));
+    Logger::instance().info("Dropped Frames: " + std::to_string(stats.droppedFrames));
+    Logger::instance().info("Duplicated Frames: " + std::to_string(stats.duplicatedFrames));
+    Logger::instance().info("Sync Error: " + std::to_string(stats.syncError * 1000) + " ms");
+    Logger::instance().info("Avg Sync Error: " + std::to_string(stats.avgSyncError * 1000) + " ms");
+    Logger::instance().info("Max Sync Error: " + std::to_string(stats.maxSyncError * 1000) + " ms");
+    Logger::instance().info("CPU Usage: " + std::to_string(stats.cpuUsage) + "%");
+    Logger::instance().info("Memory Usage: " + std::to_string(stats.memoryUsage) + " MB");
+    Logger::instance().info("Queued Packets: " + std::to_string(stats.queuedPackets));
+    Logger::instance().info("Queued Video Frames: " + std::to_string(stats.queuedVideoFrames));
+    Logger::instance().info("Queued Audio Frames: " + std::to_string(stats.queuedAudioFrames));
+    Logger::instance().info("===============================");
+}
+
+bool PlayerCoreV2::openMediaFile(const std::string& filename) {
+    // 关闭之前的文件
+    if (m_formatContext) {
+        avformat_close_input(&m_formatContext);
+        m_formatContext = nullptr;
+    }
+    
+    // 分配格式上下文
+    m_formatContext = avformat_alloc_context();
+    if (!m_formatContext) {
+        Logger::instance().error("Failed to allocate format context");
+        return false;
+    }
+    
+    // 打开输入文件
+    if (avformat_open_input(&m_formatContext, filename.c_str(), nullptr, nullptr) < 0) {
+        Logger::instance().error("Failed to open input file: " + filename);
+        avformat_free_context(m_formatContext);
+        m_formatContext = nullptr;
+        return false;
+    }
+    
+    // 查找流信息
+    if (avformat_find_stream_info(m_formatContext, nullptr) < 0) {
+        Logger::instance().error("Failed to find stream info");
+        avformat_close_input(&m_formatContext);
+        return false;
+    }
+    
+    // 查找视频和音频流
+    m_mediaInfo.videoStreamIndex = av_find_best_stream(m_formatContext, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
+    m_mediaInfo.audioStreamIndex = av_find_best_stream(m_formatContext, AVMEDIA_TYPE_AUDIO, -1, -1, nullptr, 0);
+    
+    m_mediaInfo.hasVideo = (m_mediaInfo.videoStreamIndex >= 0);
+    m_mediaInfo.hasAudio = (m_mediaInfo.audioStreamIndex >= 0);
+    
+    if (!m_mediaInfo.hasVideo && !m_mediaInfo.hasAudio) {
+        Logger::instance().error("No video or audio streams found");
+        avformat_close_input(&m_formatContext);
+        return false;
+    }
+    
+    // 获取媒体信息
+    m_mediaInfo.duration = m_formatContext->duration;
+    m_mediaInfo.bitrate = m_formatContext->bit_rate;
+    
+    if (m_mediaInfo.hasVideo) {
+        AVStream* videoStream = m_formatContext->streams[m_mediaInfo.videoStreamIndex];
+        m_mediaInfo.width = videoStream->codecpar->width;
+        m_mediaInfo.height = videoStream->codecpar->height;
+        
+        // 计算帧率
+        if (videoStream->avg_frame_rate.den != 0) {
+            m_mediaInfo.fps = av_q2d(videoStream->avg_frame_rate);
+        } else if (videoStream->r_frame_rate.den != 0) {
+            m_mediaInfo.fps = av_q2d(videoStream->r_frame_rate);
+        } else {
+            m_mediaInfo.fps = 25.0; // 默认帧率
+        }
+        
+        Logger::instance().info("Video stream found: " + std::to_string(m_mediaInfo.width) + "x" + 
+                               std::to_string(m_mediaInfo.height) + " @ " + std::to_string(m_mediaInfo.fps) + " fps");
+    }
+    
+    if (m_mediaInfo.hasAudio) {
+        AVStream* audioStream = m_formatContext->streams[m_mediaInfo.audioStreamIndex];
+        m_mediaInfo.sampleRate = audioStream->codecpar->sample_rate;
+        m_mediaInfo.channels = audioStream->codecpar->ch_layout.nb_channels;
+        
+        Logger::instance().info("Audio stream found: " + std::to_string(m_mediaInfo.sampleRate) + " Hz, " + 
+                               std::to_string(m_mediaInfo.channels) + " channels");
+    }
+    
+    // 设置同步器的流信息
+    if (m_synchronizer) {
+        m_synchronizer->setStreamInfo(m_mediaInfo.hasAudio, m_mediaInfo.hasVideo);
+        Logger::instance().info("Synchronizer stream info set: hasAudio=" + std::to_string(m_mediaInfo.hasAudio) + 
+                               ", hasVideo=" + std::to_string(m_mediaInfo.hasVideo));
+    }
+    
+    Logger::instance().info("Media file opened successfully: " + filename);
+    return true;
+}
+
+bool PlayerCoreV2::setupVideoDecoder() {
+    if (!m_mediaInfo.hasVideo || !m_videoDecoder) {
+        return false;
+    }
+    
+    AVStream* videoStream = m_formatContext->streams[m_mediaInfo.videoStreamIndex];
+    
+    // 查找解码器
+    const AVCodec* codec = avcodec_find_decoder(videoStream->codecpar->codec_id);
+    if (!codec) {
+        Logger::instance().error("Video codec not found");
+        return false;
+    }
+    
+    // 分配解码器上下文
+    AVCodecContext* codecContext = avcodec_alloc_context3(codec);
+    if (!codecContext) {
+        Logger::instance().error("Failed to allocate video codec context");
+        return false;
+    }
+    
+    // 复制流参数到解码器上下文
+    if (avcodec_parameters_to_context(codecContext, videoStream->codecpar) < 0) {
+        Logger::instance().error("Failed to copy video codec parameters");
+        avcodec_free_context(&codecContext);
+        return false;
+    }
+    
+    // 打开解码器
+    if (avcodec_open2(codecContext, codec, nullptr) < 0) {
+        Logger::instance().error("Failed to open video codec");
+        avcodec_free_context(&codecContext);
+        return false;
+    }
+    
+    // 创建视频解码器参数
+    VideoDecoderParams videoParams;
+    videoParams.codecName = codec->name;
+    videoParams.width = codecContext->width;
+    videoParams.height = codecContext->height;
+    videoParams.pixelFormat = codecContext->pix_fmt;
+    videoParams.hardwareAccel = true;
+    videoParams.lowLatency = false;
+    
+    // 初始化视频解码器
+    if (m_videoDecoder->initialize(videoParams) != ErrorCode::SUCCESS) {
+        Logger::instance().error("Failed to initialize video decoder");
+        avcodec_free_context(&codecContext);
+        return false;
+    }
+    
+    Logger::instance().info("Video decoder setup successfully");
+    return true;
+}
+
+bool PlayerCoreV2::setupAudioDecoder() {
+    if (!m_mediaInfo.hasAudio || !m_audioDecoder) {
+        return false;
+    }
+    
+    AVStream* audioStream = m_formatContext->streams[m_mediaInfo.audioStreamIndex];
+    
+    // 查找解码器
+    const AVCodec* codec = avcodec_find_decoder(audioStream->codecpar->codec_id);
+    if (!codec) {
+        Logger::instance().error("Audio codec not found");
+        return false;
+    }
+    
+    // 分配解码器上下文
+    AVCodecContext* codecContext = avcodec_alloc_context3(codec);
+    if (!codecContext) {
+        Logger::instance().error("Failed to allocate audio codec context");
+        return false;
+    }
+    
+    // 复制流参数到解码器上下文
+    if (avcodec_parameters_to_context(codecContext, audioStream->codecpar) < 0) {
+        Logger::instance().error("Failed to copy audio codec parameters");
+        avcodec_free_context(&codecContext);
+        return false;
+    }
+    
+    // 打开解码器
+    if (avcodec_open2(codecContext, codec, nullptr) < 0) {
+        Logger::instance().error("Failed to open audio codec");
+        avcodec_free_context(&codecContext);
+        return false;
+    }
+    
+    // 创建音频解码器参数
+    AudioDecoderParams audioParams;
+    audioParams.codecName = codec->name;
+    audioParams.sampleRate = codecContext->sample_rate;
+    audioParams.channels = codecContext->ch_layout.nb_channels;
+    audioParams.sampleFormat = codecContext->sample_fmt;
+    audioParams.lowLatency = false;
+    audioParams.enableResampling = true;
+    
+    // 初始化音频解码器
+    if (m_audioDecoder->initialize(audioParams) != ErrorCode::SUCCESS) {
+        Logger::instance().error("Failed to initialize audio decoder");
+        avcodec_free_context(&codecContext);
+        return false;
+    }
+    
+    // 打开音频解码器
+    if (m_audioDecoder->open(audioParams) != ErrorCode::SUCCESS) {
+        Logger::instance().error("Failed to open audio decoder");
+        avcodec_free_context(&codecContext);
+        return false;
+    }
+    
+    // 初始化音频输出设备
+    if (m_audioOutput && !m_audioOutput->initialize(codecContext->sample_rate, 
+                                                   codecContext->ch_layout.nb_channels, 
+                                                   codecContext->sample_fmt)) {
+        Logger::instance().error("Failed to initialize audio output");
+        avcodec_free_context(&codecContext);
+        return false;
+    }
+    
+    // 释放解码器上下文
+    avcodec_free_context(&codecContext);
+    
+    Logger::instance().info("Audio decoder setup successfully");
+    return true;
+}
+
+void PlayerCoreV2::resetDecoders() {
+    if (m_videoDecoder) {
+        m_videoDecoder->reset();
+    }
+    if (m_audioDecoder) {
+        m_audioDecoder->reset();
+    }
+}
+
+bool PlayerCoreV2::startReadThread() {
+    try {
+        m_readThread = std::thread(&PlayerCoreV2::readThreadFunc, this);
+        Logger::instance().info("Read thread started");
+        return true;
+    } catch (const std::exception& e) {
+        Logger::instance().error("Failed to start read thread: " + std::string(e.what()));
+        return false;
+    }
+}
+
+bool PlayerCoreV2::startDecodeThreads() {
+    try {
+        if (m_mediaInfo.hasVideo) {
+            m_videoDecodeThread = std::thread(&PlayerCoreV2::videoDecodeThreadFunc, this);
+            Logger::instance().info("Video decode thread started");
+        }
+        
+        if (m_mediaInfo.hasAudio) {
+            m_audioDecodeThread = std::thread(&PlayerCoreV2::audioDecodeThreadFunc, this);
+            Logger::instance().info("Audio decode thread started");
+        }
+        
+        return true;
+    } catch (const std::exception& e) {
+        Logger::instance().error("Failed to start decode threads: " + std::string(e.what()));
+        return false;
+    }
+}
+
+bool PlayerCoreV2::startVideoPlayThread() {
+    try {
+        m_videoPlayThread = std::thread(&PlayerCoreV2::videoPlayThreadFunc, this);
+        Logger::instance().info("Video play thread started");
+        return true;
+    } catch (const std::exception& e) {
+        Logger::instance().error("Failed to start video play thread: " + std::string(e.what()));
+        return false;
+    }
+}
+
+bool PlayerCoreV2::startAudioPlayThread() {
+    try {
+        m_audioPlayThread = std::thread(&PlayerCoreV2::audioPlayThreadFunc, this);
+        Logger::instance().info("Audio play thread started");
+        return true;
+    } catch (const std::exception& e) {
+        Logger::instance().error("Failed to start audio play thread: " + std::string(e.what()));
+        return false;
+    }
+}
+
+bool PlayerCoreV2::initializeFFmpeg() {
+    // FFmpeg初始化逻辑
+    av_log_set_level(AV_LOG_WARNING);
+    return true;
+}
+
+void PlayerCoreV2::cleanup() {
+    stopAllThreads();
+    
+    if (m_formatContext) {
+        avformat_close_input(&m_formatContext);
+        m_formatContext = nullptr;
+    }
+    
+    if (m_synchronizer) {
+        m_synchronizer->close();
+    }
+}
+
+void PlayerCoreV2::setState(PlayerState newState) {
+    PlayerState oldState = m_state.exchange(newState);
+    if (oldState != newState) {
+        notifyStateChanged(newState);
+    }
+}
+
+void PlayerCoreV2::notifyStateChanged(PlayerState newState) {
+    if (m_eventCallback) {
+        m_eventCallback->onStateChanged(newState);
+    }
+}
+
+void PlayerCoreV2::notifyError(const std::string& error) {
+    Logger::instance().error(error);
+    if (m_eventCallback) {
+        m_eventCallback->onErrorOccurred(error);
+    }
+}
+
+void PlayerCoreV2::notifyPositionChanged() {
+    if (m_eventCallback) {
+        m_eventCallback->onPositionChanged(getCurrentTime());
+    }
+}
+
+void PlayerCoreV2::handleSyncError(double error, const std::string& reason) {
+    Logger::instance().warning("Sync error: " + std::to_string(error * 1000) + "ms, reason: " + reason);
+    
+    if (m_eventCallback) {
+        m_eventCallback->onSyncError(error, reason);
+    }
+    
+    // 如果同步误差太大，尝试恢复
+    if (error > 0.2) { // 200ms
+        attemptRecovery();
+    }
+}
+
+void PlayerCoreV2::attemptRecovery() {
+    m_errorCount++;
+    m_lastErrorTime = std::chrono::steady_clock::now();
+    
+    Logger::instance().warning("Attempting recovery, error count: " + std::to_string(m_errorCount.load()));
+    
+    if (m_errorCount > 5) {
+        Logger::instance().error("Too many errors, stopping playback");
+        handleError("Too many sync errors");
+        return;
+    }
+    
+    // 重置同步器
+    if (m_synchronizer) {
+        m_synchronizer->reset();
+    }
+    
+    // 清空部分缓冲区
+    if (m_videoFrameQueue) {
+        m_videoFrameQueue->clear();
+    }
+    if (m_audioFrameQueue) {
+        m_audioFrameQueue->clear();
+    }
+}
+
+void PlayerCoreV2::handleError(const std::string& error) {
+    setState(PlayerState::Error);
+    notifyError(error);
+}
+
+void PlayerCoreV2::updateSynchronization() {
+    if (!m_synchronizer || !m_threadsRunning) {
+        return;
+    }
+    
+    // 同步器会在内部自动更新
+    // 这里可以添加额外的同步逻辑
+}
+
+void PlayerCoreV2::updateStats() {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    
+    // 更新帧率统计
+    int64_t currentFrameCount = m_frameCount;
+    int64_t frameDiff = currentFrameCount - m_lastFrameCount;
+    m_lastFrameCount = currentFrameCount;
+    
+    // 计算比特率等其他统计信息
+    if (m_formatContext) {
+        m_stats.bitrate = m_formatContext->bit_rate / 1000.0; // kbps
+    }
+}
+
+void PlayerCoreV2::updatePerformanceStats() {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    
+    m_stats.cpuUsage = calculateCpuUsage();
+    m_stats.memoryUsage = calculateMemoryUsage();
+}
+
+double PlayerCoreV2::calculateCpuUsage() {
+#ifdef _WIN32
+    FILETIME idleTime, kernelTime, userTime;
+    if (GetSystemTimes(&idleTime, &kernelTime, &userTime)) {
+        // 简化的CPU使用率计算
+        return 0.0; // 实际实现需要更复杂的逻辑
+    }
+#endif
+    return 0.0;
+}
+
+double PlayerCoreV2::calculateMemoryUsage() {
+#ifdef _WIN32
+    PROCESS_MEMORY_COUNTERS pmc;
+    if (GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc))) {
+        return pmc.WorkingSetSize / (1024.0 * 1024.0); // MB
+    }
+#endif
+    return 0.0;
+}
+
+void PlayerCoreV2::stopAllThreads() {
+    Logger::instance().info("Stopping all threads...");
+    
+    m_threadsShouldStop = true;
+    
+    // 等待线程结束
+    if (m_readThread.joinable()) {
+        m_readThread.join();
+    }
+    if (m_videoDecodeThread.joinable()) {
+        m_videoDecodeThread.join();
+    }
+    if (m_audioDecodeThread.joinable()) {
+        m_audioDecodeThread.join();
+    }
+    if (m_videoPlayThread.joinable()) {
+        m_videoPlayThread.join();
+    }
+    if (m_audioPlayThread.joinable()) {
+        m_audioPlayThread.join();
+    }
+    
+    m_threadsRunning = false;
+    Logger::instance().info("All threads stopped");
+}
+
+void PlayerCoreV2::flushBuffers() {
+    if (m_packetQueue) m_packetQueue->clear();
+    if (m_videoFrameQueue) m_videoFrameQueue->clear();
+    if (m_audioFrameQueue) m_audioFrameQueue->clear();
+}
+
+void PlayerCoreV2::readThreadFunc() {
+    Logger::instance().info("Read thread started");
+    
+    AVPacket* packet = av_packet_alloc();
+    if (!packet) {
+        Logger::instance().error("Failed to allocate packet");
+        return;
+    }
+    
+    while (!m_threadsShouldStop) {
+        // 检查是否需要seek
+        if (m_seeking) {
+            std::unique_lock<std::mutex> lock(m_seekMutex);
+            
+            // 执行seek操作
+            int64_t seekTarget = m_seekTarget;
+            int flags = AVSEEK_FLAG_BACKWARD;
+            
+            if (av_seek_frame(m_formatContext, -1, seekTarget, flags) < 0) {
+                Logger::instance().error("Seek failed");
+            } else {
+                Logger::instance().info("Seek completed to: " + std::to_string(seekTarget));
+                
+                // 清空缓冲区
+                flushBuffers();
+                
+                // 重置解码器
+                resetDecoders();
+            }
+            
+            m_seeking = false;
+            setState(m_state == PlayerState::Seeking ? PlayerState::Playing : m_state);
+            
+            lock.unlock();
+            m_seekCondition.notify_all();
+        }
+        
+        // 检查队列是否已满
+        if (m_packetQueue && m_packetQueue->size() > 1000) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+            continue;
+        }
+        
+        // 读取数据包
+        int ret = av_read_frame(m_formatContext, packet);
+        if (ret < 0) {
+            if (ret == AVERROR_EOF) {
+                Logger::instance().info("End of file reached");
+                // 文件结束，可以选择循环播放或停止
+                break;
+            } else {
+                Logger::instance().error("Error reading frame: " + std::to_string(ret));
+                std::this_thread::sleep_for(std::chrono::milliseconds(10));
+                continue;
+            }
+        }
+        
+        // 将数据包放入队列
+        if (packet->stream_index == m_mediaInfo.videoStreamIndex ||
+            packet->stream_index == m_mediaInfo.audioStreamIndex) {
+            
+            if (m_packetQueue) {
+                AVPacket* packetCopy = av_packet_alloc();
+                if (packetCopy && av_packet_ref(packetCopy, packet) == 0) {
+                    m_packetQueue->push(packetCopy);
+                } else {
+                    av_packet_free(&packetCopy);
+                }
+            }
+        }
+        
+        av_packet_unref(packet);
+    }
+    
+    av_packet_free(&packet);
+    Logger::instance().info("Read thread finished");
+}
+
+void PlayerCoreV2::videoDecodeThreadFunc() {
+    Logger::instance().info("Video decode thread started");
+    
+    while (!m_threadsShouldStop) {
+        if (!m_packetQueue || !m_videoFrameQueue || !m_videoDecoder) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+            continue;
+        }
+        
+        // 从包队列获取视频包
+        AVPacket* packet = nullptr;
+        while (!m_threadsShouldStop && !packet) {
+            packet = m_packetQueue->pop();
+            if (packet && packet->stream_index != m_mediaInfo.videoStreamIndex) {
+                // packet已经被packetPtr管理，不需要手动释放
+                packet = nullptr;
+            }
+            if (!packet) {
+                std::this_thread::sleep_for(std::chrono::milliseconds(5));
+            }
+        }
+        
+        if (!packet) continue;
+        
+        // 解码视频帧
+        AVPacketPtr packetPtr(packet);
+        std::vector<AVFramePtr> frames;
+        if (m_videoDecoder->decode(packetPtr, frames) == ErrorCode::SUCCESS) {
+            for (const auto& framePtr : frames) {
+                if (framePtr && !m_threadsShouldStop) {
+                    // 设置帧的时间戳
+                    if (framePtr->pts != AV_NOPTS_VALUE) {
+                        AVStream* stream = m_formatContext->streams[m_mediaInfo.videoStreamIndex];
+                        double pts = framePtr->pts * av_q2d(stream->time_base) * 1000000; // 转换为微秒
+                        framePtr->pts = static_cast<int64_t>(pts);
+                    }
+                    
+                    // 将帧放入队列
+                    if (m_videoFrameQueue->size() < 30) { // 限制队列大小
+                        m_videoFrameQueue->push(framePtr.get());
+                        m_frameCount++;
+                    }
+                }
+            }
+        }
+        
+        // packet已经被packetPtr管理，不需要手动释放
+    }
+    
+    Logger::instance().info("Video decode thread finished");
+}
+
+void PlayerCoreV2::audioDecodeThreadFunc() {
+    Logger::instance().info("Audio decode thread started");
+    
+    int packetCount = 0;
+    int frameCount = 0;
+    while (!m_threadsShouldStop) {
+        if (!m_packetQueue || !m_audioFrameQueue || !m_audioDecoder) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+            continue;
+        }
+        
+        // 从包队列获取音频包
+        AVPacket* packet = nullptr;
+        while (!m_threadsShouldStop && !packet) {
+            packet = m_packetQueue->pop();
+            if (packet && packet->stream_index != m_mediaInfo.audioStreamIndex) {
+                Logger::instance().debug("Skipping non-audio packet, stream_index=" + std::to_string(packet->stream_index) + 
+                                        ", expected=" + std::to_string(m_mediaInfo.audioStreamIndex));
+                av_packet_free(&packet);
+                packet = nullptr;
+            }
+            if (!packet) {
+                std::this_thread::sleep_for(std::chrono::milliseconds(5));
+            }
+        }
+        
+        if (!packet) {
+            Logger::instance().debug("Audio decode thread: no more packets available");
+            continue;
+        }
+        
+        packetCount++;
+        Logger::instance().debug("Audio decode thread got packet #" + std::to_string(packetCount) + 
+                                ", size=" + std::to_string(packet->size) + 
+                                ", pts=" + std::to_string(packet->pts));
+        
+        // 解码音频帧
+        AVPacketPtr packetPtr(packet);
+        std::vector<AVFramePtr> frames;
+        ErrorCode decodeResult = m_audioDecoder->decode(packetPtr, frames);
+        
+        Logger::instance().debug("Audio decode result: " + std::to_string(static_cast<int>(decodeResult)) + 
+                                ", frames count: " + std::to_string(frames.size()));
+        
+        if (decodeResult == ErrorCode::SUCCESS) {
+            for (const auto& framePtr : frames) {
+                if (framePtr && !m_threadsShouldStop) {
+                    frameCount++;
+                    Logger::instance().debug("Processing audio frame #" + std::to_string(frameCount) + 
+                                            ", nb_samples=" + std::to_string(framePtr->nb_samples) + 
+                                            ", pts=" + std::to_string(framePtr->pts));
+                    
+                    // 设置帧的时间戳
+                    if (framePtr->pts != AV_NOPTS_VALUE) {
+                        AVStream* stream = m_formatContext->streams[m_mediaInfo.audioStreamIndex];
+                        double pts = framePtr->pts * av_q2d(stream->time_base) * 1000000; // 转换为微秒
+                        framePtr->pts = static_cast<int64_t>(pts);
+                        Logger::instance().debug("Frame PTS converted to: " + std::to_string(framePtr->pts) + " microseconds");
+                    }
+                    
+                    // 将帧放入队列
+                    if (m_audioFrameQueue->size() < 100) { // 限制队列大小
+                        m_audioFrameQueue->push(framePtr.get());
+                        Logger::instance().debug("Audio frame pushed to queue, queue size: " + std::to_string(m_audioFrameQueue->size()));
+                    } else {
+                        Logger::instance().warning("Audio frame queue full, dropping frame");
+                    }
+                }
+            }
+        } else {
+            Logger::instance().warning("Audio decode failed with error: " + std::to_string(static_cast<int>(decodeResult)));
+        }
+        
+        // packet已经被packetPtr管理，不需要手动释放
+    }
+    
+    Logger::instance().info("Audio decode thread finished, packets processed: " + std::to_string(packetCount) + 
+                           ", frames decoded: " + std::to_string(frameCount));
+}
+
+void PlayerCoreV2::videoPlayThreadFunc() {
+    Logger::instance().info("Video play thread started");
+    
+    auto lastFrameTime = std::chrono::steady_clock::now();
+    double targetFrameInterval = 1000.0 / m_mediaInfo.fps; // 毫秒
+    
+    while (!m_threadsShouldStop) {
+        if (!m_videoFrameQueue || !m_synchronizer) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+            continue;
+        }
+        
+        // 获取视频帧
+        AVFrame* frame = m_videoFrameQueue->pop();
+        if (!frame) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(5));
+            continue;
+        }
+        
+        // 更新视频时钟
+        if (frame->pts != AV_NOPTS_VALUE) {
+            m_synchronizer->setVideoClock(frame->pts / 1000000.0); // 转换为秒
+        }
+        
+        // 检查是否应该显示这一帧
+        auto decision = m_synchronizer->shouldDisplayVideoFrame(frame->pts / 1000000.0);
+        
+        switch (decision.action) {
+            case av::utils::FrameAction::DISPLAY:
+                // 显示帧
+                if (m_openGLVideoRenderer) {
+                    AVFramePtr framePtr(frame);
+                    m_openGLVideoRenderer->renderFrame(framePtr);
+                }
+                
+                // 计算下一帧的延迟
+                if (decision.delay > 0) {
+                    auto delayMs = static_cast<int>(decision.delay * 1000);
+                    std::this_thread::sleep_for(std::chrono::milliseconds(delayMs));
+                }
+                break;
+                
+            case av::utils::FrameAction::DROP:
+                // 丢弃帧
+                Logger::instance().debug("Dropping video frame");
+                break;
+
+            case av::utils::FrameAction::Frame_DUPLICATE:
+                // 重复显示上一帧（这里简化处理）
+                if (m_openGLVideoRenderer) {
+                    AVFramePtr framePtr(frame);
+                    m_openGLVideoRenderer->renderFrame(framePtr);
+                }
+                break;
+                
+            case av::utils::FrameAction::DELAY:
+                // 延迟显示
+                auto delayMs = static_cast<int>(decision.delay * 1000);
+                std::this_thread::sleep_for(std::chrono::milliseconds(delayMs));
+                if (m_openGLVideoRenderer) {
+                    AVFramePtr framePtr(frame);
+                    m_openGLVideoRenderer->renderFrame(framePtr);
+                }
+                break;
+        }
+        
+        av_frame_free(&frame);
+        
+        // 更新帧时间
+        lastFrameTime = std::chrono::steady_clock::now();
+    }
+    
+    Logger::instance().info("Video play thread finished");
+}
+
+void PlayerCoreV2::audioPlayThreadFunc() {
+    Logger::instance().info("Audio play thread started");
+    
+    int frameCount = 0;
+    while (!m_threadsShouldStop) {
+        if (!m_audioFrameQueue || !m_synchronizer || !m_audioOutput) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+            continue;
+        }
+        
+        // 获取音频帧
+        AVFrame* frame = m_audioFrameQueue->pop();
+        if (!frame) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(5));
+            continue;
+        }
+        
+        frameCount++;
+        Logger::instance().debug("Audio play thread got frame #" + std::to_string(frameCount) + 
+                                ", pts=" + std::to_string(frame->pts) + 
+                                ", nb_samples=" + std::to_string(frame->nb_samples));
+        
+        // 更新音频时钟
+        if (frame->pts != AV_NOPTS_VALUE) {
+            m_synchronizer->setAudioClock(frame->pts / 1000000.0); // 转换为秒
+        }
+        
+        // 检查是否应该播放这一帧
+        auto decision = m_synchronizer->shouldPlayAudioFrame(frame->pts / 1000000.0);
+        
+        Logger::instance().debug("Audio frame decision: action=" + std::to_string(static_cast<int>(decision.action)) + 
+                                ", delay=" + std::to_string(decision.delay));
+        
+        switch (decision.action) {
+            case av::utils::FrameAction::DISPLAY:
+                // 播放音频帧
+                {
+                    Logger::instance().debug("Writing audio frame to output device");
+                    AVFramePtr framePtr(frame);
+                    bool writeResult = m_audioOutput->writeFrame(framePtr);
+                    Logger::instance().debug("Audio frame write result: " + std::to_string(writeResult));
+                }
+                
+                // 如果需要延迟
+                if (decision.delay > 0) {
+                    auto delayMs = static_cast<int>(decision.delay * 1000);
+                    std::this_thread::sleep_for(std::chrono::milliseconds(delayMs));
+                }
+                break;
+                
+            case av::utils::FrameAction::DROP:
+                // 丢弃音频帧
+                Logger::instance().debug("Dropping audio frame");
+                break;
+
+            case av::utils::FrameAction::Frame_DUPLICATE:
+                // 重复播放（音频中较少使用）
+                {
+                    Logger::instance().debug("Duplicating audio frame");
+                    AVFramePtr framePtr(frame);
+                    bool writeResult = m_audioOutput->writeFrame(framePtr);
+                    Logger::instance().debug("Audio frame duplicate write result: " + std::to_string(writeResult));
+                }
+                break;
+                
+            case av::utils::FrameAction::DELAY:
+                // 延迟播放
+                auto delayMs = static_cast<int>(decision.delay * 1000);
+                std::this_thread::sleep_for(std::chrono::milliseconds(delayMs));
+                {
+                    Logger::instance().debug("Writing delayed audio frame to output device");
+                    AVFramePtr framePtr(frame);
+                    bool writeResult = m_audioOutput->writeFrame(framePtr);
+                    Logger::instance().debug("Audio frame delayed write result: " + std::to_string(writeResult));
+                }
+                break;
+        }
+        
+        av_frame_free(&frame);
+    }
+    
+    Logger::instance().info("Audio play thread finished, total frames processed: " + std::to_string(frameCount));
+}
+
+} // namespace player
+} // namespace av

AV/code/player/player_core.h → AV/code/player/player_core_v2.h

@@ -1,5 +1,5 @@
-#ifndef AV_PLAYER_CORE_H
-#define AV_PLAYER_CORE_H
+#ifndef AV_PLAYER_CORE_V2_H
+#define AV_PLAYER_CORE_V2_H
 
 #pragma once
 
@@ -9,7 +9,7 @@
 #include "../codec/codec_video_decoder.h"
 #include "../utils/utils_packet_queue.h"
 #include "../utils/utils_frame_queue.h"
-#include "../utils/utils_synchronizer.h"
+#include "../utils/utils_synchronizer_v2.h"
 #include "thread_manager.h"
 #include "audio_output.h"
 #include "opengl_video_renderer.h"
@@ -20,11 +20,14 @@
 #include <string>
 #include <functional>
 #include <chrono>
+#include <thread>
+#include <condition_variable>
 
 extern "C" {
 #include <libavformat/avformat.h>
 #include <libavcodec/avcodec.h>
 #include <libavutil/avutil.h>
+#include <libavutil/time.h>
 }
 
 namespace av {
@@ -32,8 +35,12 @@ namespace player {
 
 using VideoDecoder = av::codec::VideoDecoder;
 using AudioDecoder = av::codec::AudioDecoder;
-
-using Synchronizer = av::utils::Synchronizer;
+using VideoDecoderParams = av::codec::VideoDecoderParams;
+using AudioDecoderParams = av::codec::AudioDecoderParams;
+using SynchronizerV2 = av::utils::SynchronizerV2;
+using SyncConfigV2 = av::utils::SyncConfigV2;
+using FrameDecision = av::utils::FrameDecision;
+using FrameAction = av::utils::FrameAction;
 
 /**
  * 播放器状态枚举
@@ -67,6 +74,15 @@ struct MediaInfo {
     int videoStreamIndex = -1;
     int audioStreamIndex = -1;
     int subtitleStreamIndex = -1;
+    
+    // 时间基
+    AVRational videoTimeBase;
+    AVRational audioTimeBase;
+    
+    // 兼容性字段 (与编译错误中的字段名匹配)
+    int sampleRate = 0;             // 音频采样率 (与audioSampleRate相同)
+    int channels = 0;               // 音频通道数 (与audioChannels相同)
+    double bitrate = 0.0;           // 比特率
 };
 
 /**
@@ -76,10 +92,22 @@ struct PlaybackStats {
     int64_t currentTime = 0;        // 当前播放时间(微秒)
     int64_t totalFrames = 0;        // 总帧数
     int64_t droppedFrames = 0;      // 丢帧数
+    int64_t duplicatedFrames = 0;   // 重复帧数
     double playbackSpeed = 1.0;     // 播放速度
     int queuedVideoFrames = 0;      // 视频帧队列大小
     int queuedAudioFrames = 0;      // 音频帧队列大小
     int queuedPackets = 0;          // 数据包队列大小
+    
+    // 同步统计
+    double syncError = 0.0;         // 当前同步误差
+    double avgSyncError = 0.0;      // 平均同步误差
+    double maxSyncError = 0.0;      // 最大同步误差
+    
+    // 性能统计
+    double cpuUsage = 0.0;
+    double memoryUsage = 0.0;
+    int64_t bytesRead = 0;
+    double bitrate = 0.0;
 };
 
 /**
@@ -94,18 +122,25 @@ public:
     virtual void onPositionChanged(int64_t position) = 0;  // 微秒
     virtual void onErrorOccurred(const std::string& error) = 0;
     virtual void onEndOfFile() = 0;
+    virtual void onSyncError(double error, const std::string& reason) = 0;
+    virtual void onFrameDropped(int64_t count) = 0;
 };
 
 /**
- * 播放器核心类 - 使用新的AV核心库
- * 负责媒体文件的解码和播放控制，但不涉及UI渲染
- * 这是一个纯C++实现，不依赖Qt
+ * 改进的播放器核心类 - 基于AVPlayer2的经验重新设计
+ * 
+ * 主要改进:
+ * 1. 使用新的SynchronizerV2进行精确时间同步
+ * 2. 改进的线程管理和错误处理
+ * 3. 更好的seek操作和状态管理
+ * 4. 详细的性能监控和统计
+ * 5. 自适应播放策略
  */
-class PlayerCore
+class PlayerCoreV2
 {
 public:
-    explicit PlayerCore();
-    ~PlayerCore();
+    explicit PlayerCoreV2(const SyncConfigV2& syncConfig = SyncConfigV2());
+    ~PlayerCoreV2();
 
     // 事件回调设置
     void setEventCallback(PlayerEventCallback* callback);
@@ -129,6 +164,10 @@ public:
     void setVolume(double volume);  // 0.0 - 1.0
     double getVolume() const { return m_volume; }
     
+    // 同步控制
+    void setSyncConfig(const SyncConfigV2& config);
+    SyncConfigV2 getSyncConfig() const;
+    
     // OpenGL渲染器设置
     void setOpenGLVideoRenderer(OpenGLVideoRenderer* renderer);
     OpenGLVideoRenderer* getOpenGLVideoRenderer() const { return m_openGLVideoRenderer; }
@@ -141,6 +180,10 @@ public:
     
     // 线程安全的更新接口
     void update();  // 定期调用以更新播放状态
+    
+    // 调试接口
+    std::string getDebugInfo() const;
+    void dumpStats() const;
 
 private:
     // 初始化和清理
@@ -152,6 +195,8 @@ private:
     // 线程管理
     bool startReadThread();
     bool startDecodeThreads();
+    bool startVideoPlayThread();
+    bool startAudioPlayThread();
     void stopAllThreads();
     
     // 解码器管理
@@ -162,15 +207,40 @@ private:
     // 同步控制
     void updateSynchronization();
     int64_t getCurrentPlayTime();
+    void handleSyncError(double error, const std::string& reason);
     
     // 状态管理
     void setState(PlayerState newState);
     void updateStats();
     void notifyStateChanged(PlayerState newState);
     void notifyError(const std::string& error);
+    void notifyPositionChanged();
     
     // 线程函数
     void readThreadFunc();
+    void videoDecodeThreadFunc();
+    void audioDecodeThreadFunc();
+    void videoPlayThreadFunc();
+    void audioPlayThreadFunc();
+    
+    // 帧处理
+    bool processVideoFrame();
+    bool processAudioFrame();
+    void handleVideoFrameDecision(const FrameDecision& decision, AVFrame* frame);
+    void handleAudioFrameDecision(const FrameDecision& decision, AVFrame* frame);
+    
+    // Seek处理
+    void performSeek();
+    void flushBuffers();
+    
+    // 错误处理
+    void handleError(const std::string& error);
+    void attemptRecovery();
+    
+    // 性能监控
+    void updatePerformanceStats();
+    double calculateCpuUsage();
+    double calculateMemoryUsage();
     
 private:
     // 状态变量
@@ -196,35 +266,66 @@ private:
     std::unique_ptr<av::utils::FrameQueue> m_videoFrameQueue;
     std::unique_ptr<av::utils::FrameQueue> m_audioFrameQueue;
     
-    // 同步器
-    std::unique_ptr<Synchronizer> m_synchronizer;
+    // 改进的同步器
+    std::unique_ptr<SynchronizerV2> m_synchronizer;
     
-    // 线程管理器
+    // 线程管理
     std::unique_ptr<ThreadManager> m_threadManager;
     
-    // 输出设备
+    // 音频输出
     std::unique_ptr<AudioOutput> m_audioOutput;
-    OpenGLVideoRenderer* m_openGLVideoRenderer = nullptr;  // OpenGL视频渲染器
+    
+    // 视频渲染
+    OpenGLVideoRenderer* m_openGLVideoRenderer = nullptr;
     
     // 播放控制
-    double m_volume = 1.0;
-    double m_playbackSpeed = 1.0;
-    int64_t m_seekTarget = -1;
-    std::atomic<bool> m_seeking{false};
+    std::atomic<double> m_volume{1.0};
+    std::atomic<double> m_playbackSpeed{1.0};
     
-    // 性能统计
-    int64_t m_lastUpdateTime = 0;
-    int64_t m_frameCount = 0;
+    // Seek控制
+    std::atomic<int64_t> m_seekTarget{-1};
+    std::atomic<bool> m_seeking{false};
+    std::mutex m_seekMutex;
+    std::condition_variable m_seekCondition;
     
-    // 播放时间计算
+    // 时间管理
     std::chrono::steady_clock::time_point m_playStartTime;
-    int64_t m_baseTime = 0;  // 基准时间（微秒）
+    std::atomic<int64_t> m_baseTime{0};
+    std::atomic<int64_t> m_lastUpdateTime{0};
+    
+    // 线程
+    std::thread m_readThread;
+    std::thread m_videoDecodeThread;
+    std::thread m_audioDecodeThread;
+    std::thread m_videoPlayThread;
+    std::thread m_audioPlayThread;
+    
+    // 线程控制
+    std::atomic<bool> m_threadsShouldStop{false};
+    std::atomic<bool> m_threadsRunning{false};
     
     // 初始化标志
-    bool m_initialized = false;
+    std::atomic<bool> m_initialized{false};
+    
+    // 帧计数
+    std::atomic<int64_t> m_frameCount{0};
+    std::atomic<int64_t> m_lastFrameCount{0};
+    
+    // 性能监控
+    std::chrono::steady_clock::time_point m_lastStatsUpdate;
+    std::chrono::steady_clock::time_point m_lastCpuMeasure;
+    clock_t m_lastCpuTime;
+    
+    // 错误恢复
+    std::atomic<int> m_errorCount{0};
+    std::chrono::steady_clock::time_point m_lastErrorTime;
+    
+    // 缓冲控制
+    std::atomic<bool> m_buffering{false};
+    std::atomic<double> m_bufferHealth{1.0};
 };
 
 } // namespace player
 } // namespace av
 
-#endif // AV_PLAYER_CORE_H
+#endif // AV_PLAYER_CORE_V2_H

AV/code/player/thread_manager.cpp

@@ -1,17 +1,15 @@
 #include "thread_manager.h"
 
-#include "../utils/utils_packet_queue.h"
-#include "../utils/utils_frame_queue.h"
-#include "thread_manager.h"
 #include "../base/logger.h"
 #include "../base/media_common.h"
-#include "../codec/codec_video_decoder.h"
 #include "../codec/codec_audio_decoder.h"
-#include "../utils/utils_packet_queue.h"
+#include "../codec/codec_video_decoder.h"
 #include "../utils/utils_frame_queue.h"
-#include "../utils/utils_synchronizer.h"
-#include <thread>
+#include "../utils/utils_packet_queue.h"
+#include "../utils/utils_synchronizer_v2.h"
+#include "thread_manager.h"
 #include <chrono>
+#include <thread>
 #include <vector>
 
 namespace av {
@@ -190,12 +188,12 @@ void ReadThread::handleSeek()
 
 // VideoDecodeThread 实现
 VideoDecodeThread::VideoDecodeThread(av::utils::PacketQueue* packetQueue,
-                                      av::utils::FrameQueue* frameQueue,
-                                      VideoDecoder* decoder,
-                                      av::utils::Synchronizer* synchronizer,
-                                      int streamIndex,
-                                      AVCodecParameters* codecParams,
-                                      AVRational timeBase)
+                                     av::utils::FrameQueue* frameQueue,
+                                     VideoDecoder* decoder,
+                                     av::utils::SynchronizerV2* synchronizer,
+                                     int streamIndex,
+                                     AVCodecParameters* codecParams,
+                                     AVRational timeBase)
     : ThreadBase("VideoDecodeThread")
     , m_packetQueue(packetQueue)
     , m_frameQueue(frameQueue)
@@ -377,11 +375,11 @@ void VideoDecodeThread::cleanupBitStreamFilter()
 
 // AudioDecodeThread 实现
 AudioDecodeThread::AudioDecodeThread(av::utils::PacketQueue* packetQueue,
-                                      av::utils::FrameQueue* frameQueue,
-                                      AudioDecoder* decoder,
-                                      av::utils::Synchronizer* synchronizer,
-                                      int streamIndex,
-                                      AVRational timeBase)
+                                     av::utils::FrameQueue* frameQueue,
+                                     AudioDecoder* decoder,
+                                     av::utils::SynchronizerV2* synchronizer,
+                                     int streamIndex,
+                                     AVRational timeBase)
     : ThreadBase("AudioDecodeThread")
     , m_packetQueue(packetQueue)
     , m_frameQueue(frameQueue)
@@ -516,7 +514,7 @@ bool ThreadManager::createReadThread(AVFormatContext* formatContext,
 bool ThreadManager::createVideoDecodeThread(av::utils::PacketQueue* packetQueue,
                                             av::utils::FrameQueue* frameQueue,
                                             VideoDecoder* decoder,
-                                            av::utils::Synchronizer* synchronizer,
+                                            av::utils::SynchronizerV2* synchronizer,
                                             int streamIndex,
                                             AVCodecParameters* codecParams,
                                             AVRational timeBase)
@@ -535,7 +533,7 @@ bool ThreadManager::createVideoDecodeThread(av::utils::PacketQueue* packetQueue,
 bool ThreadManager::createAudioDecodeThread(av::utils::PacketQueue* packetQueue,
                                             av::utils::FrameQueue* frameQueue,
                                             AudioDecoder* decoder,
-                                            av::utils::Synchronizer* synchronizer,
+                                            av::utils::SynchronizerV2* synchronizer,
                                             int streamIndex,
                                             AVRational timeBase)
 {

AV/code/player/thread_manager.h

@@ -26,7 +26,7 @@ namespace player {
 }
 
 namespace utils {
-class Synchronizer;
+class SynchronizerV2;
 }
 
 namespace utils {
@@ -138,15 +138,15 @@ private:
 class VideoDecodeThread : public ThreadBase {
 public:
     VideoDecodeThread(av::utils::PacketQueue* packetQueue,
-                       av::utils::FrameQueue* frameQueue,
-                       VideoDecoder* decoder,
-                       av::utils::Synchronizer* synchronizer,
-                       int streamIndex,
-                       AVCodecParameters* codecParams = nullptr,
-                       AVRational timeBase = {1, 1000000});
-    
+                      av::utils::FrameQueue* frameQueue,
+                      VideoDecoder* decoder,
+                      av::utils::SynchronizerV2* synchronizer,
+                      int streamIndex,
+                      AVCodecParameters* codecParams = nullptr,
+                      AVRational timeBase = {1, 1000000});
+
     ~VideoDecodeThread() override;
-    
+
     /**
      * @brief 设置帧输出回调函数
      */
@@ -159,7 +159,7 @@ private:
     av::utils::PacketQueue* m_packetQueue;
     av::utils::FrameQueue* m_frameQueue;
     VideoDecoder* m_decoder;
-    av::utils::Synchronizer* m_synchronizer;
+    av::utils::SynchronizerV2* m_synchronizer;
     int m_streamIndex;
     AVBSFContext* m_bsfContext;
     FrameOutputCallback m_frameOutputCallback;
@@ -176,14 +176,14 @@ private:
 class AudioDecodeThread : public ThreadBase {
 public:
     AudioDecodeThread(av::utils::PacketQueue* packetQueue,
-                       av::utils::FrameQueue* frameQueue,
-                       AudioDecoder* decoder,
-                       av::utils::Synchronizer* synchronizer,
-                       int streamIndex,
-                       AVRational timeBase = {1, 1000000});
-    
+                      av::utils::FrameQueue* frameQueue,
+                      AudioDecoder* decoder,
+                      av::utils::SynchronizerV2* synchronizer,
+                      int streamIndex,
+                      AVRational timeBase = {1, 1000000});
+
     ~AudioDecodeThread() override = default;
-    
+
     /**
      * @brief 设置帧输出回调函数
      */
@@ -196,7 +196,7 @@ private:
     av::utils::PacketQueue* m_packetQueue;
     av::utils::FrameQueue* m_frameQueue;
     AudioDecoder* m_decoder;
-    av::utils::Synchronizer* m_synchronizer;
+    av::utils::SynchronizerV2* m_synchronizer;
     int m_streamIndex;
     FrameOutputCallback m_frameOutputCallback;
     AVRational m_timeBase;
@@ -228,23 +228,23 @@ public:
      * @brief 创建视频解码线程
      */
     bool createVideoDecodeThread(av::utils::PacketQueue* packetQueue,
-                                  av::utils::FrameQueue* frameQueue,
-                                  VideoDecoder* decoder,
-                                  av::utils::Synchronizer* synchronizer,
-                                  int streamIndex,
-                                  AVCodecParameters* codecParams = nullptr,
-                                  AVRational timeBase = {1, 1000000});
-    
+                                 av::utils::FrameQueue* frameQueue,
+                                 VideoDecoder* decoder,
+                                 av::utils::SynchronizerV2* synchronizer,
+                                 int streamIndex,
+                                 AVCodecParameters* codecParams = nullptr,
+                                 AVRational timeBase = {1, 1000000});
+
     /**
      * @brief 创建音频解码线程
      */
     bool createAudioDecodeThread(av::utils::PacketQueue* packetQueue,
-                                  av::utils::FrameQueue* frameQueue,
-                                  AudioDecoder* decoder,
-                                  av::utils::Synchronizer* synchronizer,
-                                  int streamIndex,
-                                  AVRational timeBase = {1, 1000000});
-    
+                                 av::utils::FrameQueue* frameQueue,
+                                 AudioDecoder* decoder,
+                                 av::utils::SynchronizerV2* synchronizer,
+                                 int streamIndex,
+                                 AVRational timeBase = {1, 1000000});
+
     /**
      * @brief 启动所有线程
      */

AV/code/utils/utils_frame_queue.h

@@ -129,6 +129,17 @@ public:
     AVFrame* dequeueFrame();
     AVFrame* dequeueFrame(int timeoutMs);
     
+    // 兼容性方法 (push/pop 别名)
+    ErrorCode push(AVFrame* frame, int streamIndex = -1) {
+        return enqueue(frame, streamIndex);
+    }
+    AVFrame* pop() {
+        return dequeueFrame();
+    }
+    AVFrame* pop(int timeoutMs) {
+        return dequeueFrame(timeoutMs);
+    }
+    
     // 队列控制
     void clear();
     void flush();

AV/code/utils/utils_packet_queue.h

@@ -157,6 +157,17 @@ public:
     AVPacket* dequeuePacket();
     AVPacket* dequeuePacket(int timeoutMs);
     
+    // 兼容性方法 (push/pop 别名)
+    ErrorCode push(AVPacket* packet, int streamIndex = -1, int priority = 0) {
+        return enqueue(packet, streamIndex, priority);
+    }
+    AVPacket* pop() {
+        return dequeuePacket();
+    }
+    AVPacket* pop(int timeoutMs) {
+        return dequeuePacket(timeoutMs);
+    }
+    
     // 优先级队列操作
     ErrorCode enqueueWithPriority(AVPacket* packet, int priority, int streamIndex = -1);
     std::unique_ptr<PacketQueueItem> dequeueHighestPriority();

AV/code/utils/utils_synchronizer.cpp

@@ -1,1330 +0,0 @@
-#include "utils_synchronizer.h"
-#include "../base/logger.h"
-#include <algorithm>
-#include <cmath>
-#include <shared_mutex>
-
-namespace av {
-namespace utils {
-
-using namespace av;
-
-Synchronizer::Synchronizer(const SyncConfig& config)
-    : config_(config)
-    , masterClockType_(ClockType::AUDIO)
-    , state_(SyncState::IDLE)
-    , initialized_(false)
-    , running_(false)
-    , paused_(false) {
-    
-    // 初始化时钟
-    audioClock_ = ClockInfo();
-    videoClock_ = ClockInfo();
-    externalClock_ = ClockInfo();
-    
-    // 初始化历史记录
-    audioClockHistory_.reserve(config_.smoothingWindow);
-    videoClockHistory_.reserve(config_.smoothingWindow);
-    syncErrorHistory_.reserve(config_.smoothingWindow);
-    
-    Logger::instance().debugf("Synchronizer created with strategy: {}", static_cast<int>(config_.strategy));
-}
-
-Synchronizer::~Synchronizer() {
-    close();
-    Logger::instance().debug("Synchronizer destroyed");
-}
-
-ErrorCode Synchronizer::initialize() {
-    if (initialized_) {
-        return ErrorCode::ALREADY_INITIALIZED;
-    }
-    
-    std::lock_guard<std::mutex> lock(clockMutex_);
-    
-    // 重置所有时钟
-    resetClock(ClockType::AUDIO);
-    resetClock(ClockType::VIDEO);
-    resetClock(ClockType::EXTERNAL);
-    
-    // 选择主时钟
-    selectMasterClock();
-    
-    // 重置统计信息
-    resetStats();
-    
-    // 设置开始时间
-    startTime_ = std::chrono::steady_clock::now();
-    lastClockUpdate_ = startTime_;
-    
-    state_ = SyncState::IDLE;
-    initialized_ = true;
-    
-    Logger::instance().info("Synchronizer initialized");
-    return ErrorCode::SUCCESS;
-}
-
-ErrorCode Synchronizer::start() {
-    if (!initialized_) {
-        return ErrorCode::NOT_INITIALIZED;
-    }
-    
-    if (running_) {
-        return ErrorCode::ALREADY_STARTED;
-    }
-    
-    running_ = true;
-    paused_ = false;
-    state_ = SyncState::SYNCING;
-    
-    startTime_ = std::chrono::steady_clock::now();
-    
-    Logger::instance().info("Synchronizer started");
-    return ErrorCode::SUCCESS;
-}
-
-ErrorCode Synchronizer::stop() {
-    if (!running_) {
-        return ErrorCode::NOT_STARTED;
-    }
-    
-    running_ = false;
-    paused_ = false;
-    state_ = SyncState::IDLE;
-    
-    Logger::instance().info("Synchronizer stopped");
-    return ErrorCode::SUCCESS;
-}
-
-ErrorCode Synchronizer::pause() {
-    if (!running_) {
-        return ErrorCode::NOT_STARTED;
-    }
-    
-    if (paused_) {
-        return ErrorCode::ALREADY_PAUSED;
-    }
-    
-    std::lock_guard<std::mutex> lock(clockMutex_);
-    
-    paused_ = true;
-    
-    // 暂停所有时钟
-    pauseClock(ClockType::AUDIO, true);
-    pauseClock(ClockType::VIDEO, true);
-    pauseClock(ClockType::EXTERNAL, true);
-    
-    Logger::instance().info("Synchronizer paused");
-    return ErrorCode::SUCCESS;
-}
-
-ErrorCode Synchronizer::resume() {
-    if (!running_) {
-        return ErrorCode::NOT_STARTED;
-    }
-    
-    if (!paused_) {
-        return ErrorCode::NOT_PAUSED;
-    }
-    
-    std::lock_guard<std::mutex> lock(clockMutex_);
-    
-    paused_ = false;
-    
-    // 恢复所有时钟
-    pauseClock(ClockType::AUDIO, false);
-    pauseClock(ClockType::VIDEO, false);
-    pauseClock(ClockType::EXTERNAL, false);
-    
-    state_ = SyncState::SYNCING;
-    
-    Logger::instance().info("Synchronizer resumed");
-    return ErrorCode::SUCCESS;
-}
-
-ErrorCode Synchronizer::reset() {
-    std::lock_guard<std::mutex> clockLock(clockMutex_);
-    std::lock_guard<std::mutex> statsLock(statsMutex_);
-    
-    // 重置时钟
-    resetClock(ClockType::AUDIO);
-    resetClock(ClockType::VIDEO);
-    resetClock(ClockType::EXTERNAL);
-    
-    // 重置统计信息
-    stats_ = SyncStats();
-    
-    // 清空历史记录
-    audioClockHistory_.clear();
-    videoClockHistory_.clear();
-    syncErrorHistory_.clear();
-    
-    // 重置状态
-    state_ = running_ ? SyncState::SYNCING : SyncState::IDLE;
-    
-    // 重新选择主时钟
-    selectMasterClock();
-    
-    Logger::instance().info("Synchronizer reset");
-    return ErrorCode::SUCCESS;
-}
-
-ErrorCode Synchronizer::close() {
-    if (running_) {
-        stop();
-    }
-    
-    initialized_ = false;
-    
-    Logger::instance().info("Synchronizer closed");
-    return ErrorCode::SUCCESS;
-}
-
-ErrorCode Synchronizer::setAudioClock(double pts, double time) {
-    return updateClock(ClockType::AUDIO, pts, time);
-}
-
-ErrorCode Synchronizer::setVideoClock(double pts, double time) {
-    return updateClock(ClockType::VIDEO, pts, time);
-}
-
-ErrorCode Synchronizer::setExternalClock(double time) {
-    if (time < 0) {
-        time = getCurrentTime();
-    }
-    
-    std::lock_guard<std::mutex> lock(clockMutex_);
-    
-    externalClock_.pts = time;
-    externalClock_.time = time;
-    externalClock_.lastUpdate = std::chrono::steady_clock::now();
-    
-    if (config_.enableStats) {
-        updateStats();
-    }
-    
-    return ErrorCode::SUCCESS;
-}
-
-ErrorCode Synchronizer::updateClock(ClockType type, double pts, double time) {
-    if (!running_) {
-        return ErrorCode::NOT_STARTED;
-    }
-    
-    if (time < 0) {
-        time = getCurrentTime();
-    }
-    
-    std::lock_guard<std::mutex> lock(clockMutex_);
-    
-    ClockInfo* clock = nullptr;
-    switch (type) {
-        case ClockType::AUDIO:
-            clock = &audioClock_;
-            break;
-        case ClockType::VIDEO:
-            clock = &videoClock_;
-            break;
-        case ClockType::EXTERNAL:
-            clock = &externalClock_;
-            break;
-    }
-    
-    if (!clock) {
-        return ErrorCode::INVALID_PARAMS;
-    }
-    
-    // 平滑处理
-    double smoothedPts = config_.enableAdaptiveSync ? smoothClock(type, pts) : pts;
-    
-    clock->pts = smoothedPts;
-    clock->time = time;
-    clock->lastUpdate = std::chrono::steady_clock::now();
-    
-    // 更新主时钟
-    updateMasterClock();
-    
-    // 更新同步状态
-    updateSyncState();
-    
-    // 更新统计信息
-    if (config_.enableStats) {
-        updateStats();
-    }
-    
-    return ErrorCode::SUCCESS;
-}
-
-double Synchronizer::getAudioClock() const {
-    return getClockValue(ClockType::AUDIO);
-}
-
-double Synchronizer::getVideoClock() const {
-    return getClockValue(ClockType::VIDEO);
-}
-
-double Synchronizer::getExternalClock() const {
-    return getClockValue(ClockType::EXTERNAL);
-}
-
-double Synchronizer::getMasterClock() const {
-    return getClockValue(masterClockType_);
-}
-
-ClockType Synchronizer::getMasterClockType() const {
-    return masterClockType_;
-}
-
-ErrorCode Synchronizer::synchronize() {
-    if (!running_) {
-        return ErrorCode::NOT_STARTED;
-    }
-    
-    std::lock_guard<std::mutex> lock(clockMutex_);
-    
-    // 更新主时钟
-    updateMasterClock();
-    
-    // 计算同步误差
-    double syncError = calculateSyncError();
-    
-    // 检查是否需要调整
-    if (std::abs(syncError) > config_.syncThreshold) {
-        // 调整播放速度
-        if (config_.enableAdaptiveSync) {
-            adjustPlaybackSpeed();
-        }
-        
-        // 更新状态
-        if (std::abs(syncError) > config_.maxSyncError) {
-            state_ = SyncState::ERROR;
-        } else {
-            state_ = SyncState::DRIFT;
-        }
-    } else {
-        state_ = SyncState::SYNCHRONIZED;
-    }
-    
-    // 更新统计信息
-    if (config_.enableStats) {
-        updateSyncError(syncError);
-    }
-    
-    // 通知状态变化
-    if (syncEventCallback_) {
-        syncEventCallback_(state_, syncError);
-    }
-    
-    return ErrorCode::SUCCESS;
-}
-
-ErrorCode Synchronizer::synchronizeAudio(double audioPts, double& delay) {
-    if (!running_) {
-        return ErrorCode::NOT_STARTED;
-    }
-    
-    // 更新音频时钟
-    updateClock(ClockType::AUDIO, audioPts);
-    
-    // 计算延迟
-    delay = calculateAudioDelay(audioPts);
-    
-    // 检查是否需要丢帧
-    if (config_.enableFrameDrop && shouldDropFrame(ClockType::AUDIO, audioPts)) {
-        if (frameDropCallback_) {
-            frameDropCallback_(ClockType::AUDIO, audioPts);
-        }
-        updateDropCount();
-    }
-    
-    return ErrorCode::SUCCESS;
-}
-
-ErrorCode Synchronizer::synchronizeVideo(double videoPts, double& delay) {
-    if (!running_) {
-        return ErrorCode::NOT_STARTED;
-    }
-    
-    // 更新视频时钟
-    updateClock(ClockType::VIDEO, videoPts);
-    
-    // 计算延迟
-    delay = calculateVideoDelay(videoPts);
-    
-    // 检查是否需要丢帧或重复帧
-    if (config_.enableFrameDrop && shouldDropFrame(ClockType::VIDEO, videoPts)) {
-        if (frameDropCallback_) {
-            frameDropCallback_(ClockType::VIDEO, videoPts);
-        }
-        updateDropCount();
-    } else if (config_.enableFrameDuplicate && shouldDuplicateFrame(ClockType::VIDEO, videoPts)) {
-        if (frameDuplicateCallback_) {
-            frameDuplicateCallback_(ClockType::VIDEO, videoPts);
-        }
-        updateDuplicateCount();
-    }
-    
-    return ErrorCode::SUCCESS;
-}
-
-bool Synchronizer::shouldDropFrame(ClockType type, double pts) {
-    return needFrameDrop(type, pts);
-}
-
-bool Synchronizer::shouldDuplicateFrame(ClockType type, double pts) {
-    return needFrameDuplicate(type, pts);
-}
-
-double Synchronizer::calculateAudioDelay(double audioPts) const {
-    double masterClock = getMasterClock();
-    double delay = audioPts - masterClock;
-    
-    // 限制延迟范围
-    delay = std::max(-config_.maxAudioDelay, std::min(config_.maxAudioDelay, delay));
-    
-    return delay;
-}
-
-double Synchronizer::calculateVideoDelay(double videoPts) const {
-    double masterClock = getMasterClock();
-    double delay = videoPts - masterClock;
-    
-    // 限制延迟范围
-    delay = std::max(-config_.maxVideoDelay, std::min(config_.maxVideoDelay, delay));
-    
-    return delay;
-}
-
-double Synchronizer::calculateSyncError() const {
-    double audioClock = getAudioClock();
-    double videoClock = getVideoClock();
-    
-    if (audioClock <= 0 || videoClock <= 0) {
-        return 0.0;
-    }
-    
-    return std::abs(audioClock - videoClock);
-}
-
-void Synchronizer::setConfig(const SyncConfig& config) {
-    std::lock_guard<std::mutex> lock(configMutex_);
-    config_ = config;
-    
-    // 重新选择主时钟
-    selectMasterClock();
-    
-    Logger::instance().debug("Synchronizer config updated");
-}
-
-SyncConfig Synchronizer::getConfig() const {
-    std::lock_guard<std::mutex> lock(configMutex_);
-    return config_;
-}
-
-void Synchronizer::setSyncStrategy(SyncStrategy strategy) {
-    std::lock_guard<std::mutex> lock(configMutex_);
-    config_.strategy = strategy;
-    selectMasterClock();
-    
-    Logger::instance().debugf("Sync strategy set to: {}", static_cast<int>(strategy));
-}
-
-SyncStrategy Synchronizer::getSyncStrategy() const {
-    std::lock_guard<std::mutex> lock(configMutex_);
-    return config_.strategy;
-}
-
-void Synchronizer::setSyncThreshold(double threshold) {
-    std::lock_guard<std::mutex> lock(configMutex_);
-    config_.syncThreshold = threshold;
-    
-    Logger::instance().debugf("Sync threshold set to: {}ms", threshold * 1000);
-}
-
-void Synchronizer::setMaxSyncError(double maxError) {
-    std::lock_guard<std::mutex> lock(configMutex_);
-    config_.maxSyncError = maxError;
-    
-    Logger::instance().debugf("Max sync error set to: {}ms", maxError * 1000);
-}
-
-void Synchronizer::setPlaybackSpeed(double speed) {
-    std::lock_guard<std::mutex> lock(clockMutex_);
-    
-    audioClock_.speed = speed;
-    videoClock_.speed = speed;
-    externalClock_.speed = speed;
-    
-    Logger::instance().debugf("Playback speed set to: {}x", speed);
-}
-
-double Synchronizer::getPlaybackSpeed() const {
-    std::lock_guard<std::mutex> lock(clockMutex_);
-    return audioClock_.speed;
-}
-
-void Synchronizer::setPaused(bool paused) {
-    if (paused) {
-        pause();
-    } else {
-        resume();
-    }
-}
-
-bool Synchronizer::isPaused() const {
-    return paused_;
-}
-
-SyncState Synchronizer::getState() const {
-    return state_;
-}
-
-bool Synchronizer::isSynchronized() const {
-    return state_ == SyncState::SYNCHRONIZED;
-}
-
-SyncStats Synchronizer::getStats() const {
-    std::lock_guard<std::mutex> lock(statsMutex_);
-    SyncStats stats = stats_;
-    
-    // 更新当前时钟值
-    stats.audioClock = getAudioClock();
-    stats.videoClock = getVideoClock();
-    stats.externalClock = getExternalClock();
-    stats.masterClock = getMasterClock();
-    stats.state = state_;
-    
-    return stats;
-}
-
-void Synchronizer::resetStats() {
-    std::lock_guard<std::mutex> lock(statsMutex_);
-    stats_ = SyncStats();
-    stats_.lastUpdateTime = std::chrono::steady_clock::now();
-    
-    Logger::instance().debug("Synchronizer stats reset");
-}
-
-void Synchronizer::setSyncEventCallback(SyncEventCallback callback) {
-    syncEventCallback_ = callback;
-}
-
-void Synchronizer::setFrameDropCallback(FrameDropCallback callback) {
-    frameDropCallback_ = callback;
-}
-
-void Synchronizer::setFrameDuplicateCallback(FrameDuplicateCallback callback) {
-    frameDuplicateCallback_ = callback;
-}
-
-void Synchronizer::enableAdaptiveSync(bool enable) {
-    std::lock_guard<std::mutex> lock(configMutex_);
-    config_.enableAdaptiveSync = enable;
-    
-    Logger::instance().debugf("Adaptive sync {}", enable ? "enabled" : "disabled");
-}
-
-void Synchronizer::setClockUpdateInterval(double interval) {
-    std::lock_guard<std::mutex> lock(configMutex_);
-    config_.clockUpdateInterval = interval;
-    
-    Logger::instance().debugf("Clock update interval set to: {}ms", interval * 1000);
-}
-
-void Synchronizer::setSmoothingWindow(int window) {
-    std::lock_guard<std::mutex> lock(configMutex_);
-    config_.smoothingWindow = window;
-    
-    // 调整历史记录大小
-    audioClockHistory_.reserve(window);
-    videoClockHistory_.reserve(window);
-    syncErrorHistory_.reserve(window);
-    
-    Logger::instance().debugf("Smoothing window set to: {}", window);
-}
-
-// 内部方法实现
-void Synchronizer::updateMasterClock() {
-    // 根据策略选择主时钟
-    switch (config_.strategy) {
-        case SyncStrategy::AUDIO_MASTER:
-            masterClockType_ = ClockType::AUDIO;
-            break;
-        case SyncStrategy::VIDEO_MASTER:
-            masterClockType_ = ClockType::VIDEO;
-            break;
-        case SyncStrategy::EXTERNAL_CLOCK:
-            masterClockType_ = ClockType::EXTERNAL;
-            break;
-        case SyncStrategy::AUTO_SELECT:
-            selectMasterClock();
-            break;
-    }
-}
-
-void Synchronizer::updateSyncState() {
-    if (!running_) {
-        state_ = SyncState::IDLE;
-        return;
-    }
-    
-    if (paused_) {
-        return;
-    }
-    
-    double syncError = calculateSyncError();
-    
-    if (syncError <= config_.syncThreshold) {
-        state_ = SyncState::SYNCHRONIZED;
-    } else if (syncError <= config_.maxSyncError) {
-        state_ = SyncState::DRIFT;
-    } else {
-        state_ = SyncState::ERROR;
-    }
-}
-
-void Synchronizer::updateStats() {
-    std::lock_guard<std::mutex> lock(statsMutex_);
-    
-    stats_.audioClock = getAudioClock();
-    stats_.videoClock = getVideoClock();
-    stats_.externalClock = getExternalClock();
-    stats_.masterClock = getMasterClock();
-    stats_.audioDelay = calculateAudioDelay(stats_.audioClock);
-    stats_.videoDelay = calculateVideoDelay(stats_.videoClock);
-    stats_.syncError = calculateSyncError();
-    stats_.state = state_;
-    stats_.lastUpdateTime = std::chrono::steady_clock::now();
-    
-    // 更新最大同步误差
-    stats_.maxSyncError = std::max(stats_.maxSyncError, stats_.syncError);
-    
-    // 更新同步次数
-    stats_.syncCount++;
-    
-    // 更新平均同步误差
-    if (stats_.syncCount == 1) {
-        stats_.avgSyncError = stats_.syncError;
-    } else {
-        stats_.avgSyncError = (stats_.avgSyncError * (stats_.syncCount - 1) + stats_.syncError) / stats_.syncCount;
-    }
-}
-
-double Synchronizer::getCurrentTime() const {
-    auto now = std::chrono::steady_clock::now();
-    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(now - startTime_);
-    return duration.count() / 1000000.0; // 转换为秒
-}
-
-double Synchronizer::smoothClock(ClockType type, double newValue) {
-    std::vector<double>* history = nullptr;
-    
-    switch (type) {
-        case ClockType::AUDIO:
-            history = &audioClockHistory_;
-            break;
-        case ClockType::VIDEO:
-            history = &videoClockHistory_;
-            break;
-        default:
-            return newValue;
-    }
-    
-    // 添加新值到历史记录
-    history->push_back(newValue);
-    
-    // 保持历史记录大小
-    if (history->size() > static_cast<size_t>(config_.smoothingWindow)) {
-        history->erase(history->begin());
-    }
-    
-    // 计算平均值
-    double sum = 0.0;
-    for (double value : *history) {
-        sum += value;
-    }
-    
-    return sum / history->size();
-}
-
-bool Synchronizer::isClockValid(ClockType type) const {
-    const ClockInfo* clock = nullptr;
-    
-    switch (type) {
-        case ClockType::AUDIO:
-            clock = &audioClock_;
-            break;
-        case ClockType::VIDEO:
-            clock = &videoClock_;
-            break;
-        case ClockType::EXTERNAL:
-            clock = &externalClock_;
-            break;
-    }
-    
-    if (!clock) {
-        return false;
-    }
-    
-    // 检查时钟是否有效（最近更新过）
-    auto now = std::chrono::steady_clock::now();
-    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - clock->lastUpdate);
-    
-    return elapsed.count() < 1000; // 1秒内更新过认为有效
-}
-
-void Synchronizer::selectMasterClock() {
-    // 自动选择最稳定的时钟作为主时钟
-    if (isClockValid(ClockType::AUDIO)) {
-        masterClockType_ = ClockType::AUDIO;
-    } else if (isClockValid(ClockType::VIDEO)) {
-        masterClockType_ = ClockType::VIDEO;
-    } else {
-        masterClockType_ = ClockType::EXTERNAL;
-    }
-}
-
-void Synchronizer::handleSyncDrift() {
-    // 处理时钟漂移
-    double syncError = calculateSyncError();
-    
-    if (syncError > config_.maxSyncError) {
-        // 重置时钟
-        Logger::instance().warning("Sync drift detected, resetting clocks");
-        reset();
-    }
-}
-
-void Synchronizer::notifyStateChange(SyncState newState) {
-    if (state_ != newState) {
-        SyncState oldState = state_;
-        state_ = newState;
-        
-        if (syncEventCallback_) {
-            syncEventCallback_(newState, calculateSyncError());
-        }
-        
-        Logger::instance().debugf("Sync state changed from {} to {}", 
-                     static_cast<int>(oldState), static_cast<int>(newState));
-    }
-}
-
-double Synchronizer::getClockValue(ClockType type) const {
-    std::lock_guard<std::mutex> lock(clockMutex_);
-    
-    const ClockInfo* clock = nullptr;
-    
-    switch (type) {
-        case ClockType::AUDIO:
-            clock = &audioClock_;
-            break;
-        case ClockType::VIDEO:
-            clock = &videoClock_;
-            break;
-        case ClockType::EXTERNAL:
-            clock = &externalClock_;
-            break;
-    }
-    
-    if (!clock || clock->paused) {
-        return clock ? clock->pts : 0.0;
-    }
-    
-    // 计算当前时钟值
-    auto now = std::chrono::steady_clock::now();
-    auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(now - clock->lastUpdate);
-    double elapsedSeconds = elapsed.count() / 1000000.0;
-    
-    return clock->pts + elapsedSeconds * clock->speed;
-}
-
-void Synchronizer::setClockValue(ClockType type, double value, double time) {
-    ClockInfo* clock = nullptr;
-    
-    switch (type) {
-        case ClockType::AUDIO:
-            clock = &audioClock_;
-            break;
-        case ClockType::VIDEO:
-            clock = &videoClock_;
-            break;
-        case ClockType::EXTERNAL:
-            clock = &externalClock_;
-            break;
-    }
-    
-    if (clock) {
-        clock->pts = value;
-        clock->time = (time >= 0) ? time : getCurrentTime();
-        clock->lastUpdate = std::chrono::steady_clock::now();
-    }
-}
-
-void Synchronizer::resetClock(ClockType type) {
-    ClockInfo* clock = nullptr;
-    
-    switch (type) {
-        case ClockType::AUDIO:
-            clock = &audioClock_;
-            break;
-        case ClockType::VIDEO:
-            clock = &videoClock_;
-            break;
-        case ClockType::EXTERNAL:
-            clock = &externalClock_;
-            break;
-    }
-    
-    if (clock) {
-        *clock = ClockInfo();
-        clock->lastUpdate = std::chrono::steady_clock::now();
-    }
-}
-
-void Synchronizer::pauseClock(ClockType type, bool pause) {
-    ClockInfo* clock = nullptr;
-    
-    switch (type) {
-        case ClockType::AUDIO:
-            clock = &audioClock_;
-            break;
-        case ClockType::VIDEO:
-            clock = &videoClock_;
-            break;
-        case ClockType::EXTERNAL:
-            clock = &externalClock_;
-            break;
-    }
-    
-    if (clock) {
-        clock->paused = pause;
-        if (!pause) {
-            clock->lastUpdate = std::chrono::steady_clock::now();
-        }
-    }
-}
-
-double Synchronizer::calculateOptimalDelay(ClockType type, double pts) {
-    double masterClock = getMasterClock();
-    double delay = pts - masterClock;
-    
-    // 根据类型调整延迟
-    if (type == ClockType::AUDIO) {
-        delay = std::max(-config_.maxAudioDelay, std::min(config_.maxAudioDelay, delay));
-    } else if (type == ClockType::VIDEO) {
-        delay = std::max(-config_.maxVideoDelay, std::min(config_.maxVideoDelay, delay));
-    }
-    
-    return delay;
-}
-
-bool Synchronizer::needFrameDrop(ClockType type, double pts) {
-    double delay = calculateOptimalDelay(type, pts);
-    
-    // 如果延迟太大（帧太晚），需要丢帧
-    if (type == ClockType::AUDIO) {
-        return delay < -config_.maxAudioDelay / 2;
-    } else if (type == ClockType::VIDEO) {
-        return delay < -config_.maxVideoDelay / 2;
-    }
-    
-    return false;
-}
-
-bool Synchronizer::needFrameDuplicate(ClockType type, double pts) {
-    double delay = calculateOptimalDelay(type, pts);
-    
-    // 如果延迟太小（帧太早），需要重复帧
-    if (type == ClockType::VIDEO) {
-        return delay > config_.maxVideoDelay / 2;
-    }
-    
-    return false;
-}
-
-void Synchronizer::adjustPlaybackSpeed() {
-    double syncError = calculateSyncError();
-    
-    if (syncError > config_.syncThreshold) {
-        // 根据同步误差调整播放速度
-        double speedAdjustment = std::min(0.1, syncError / 10.0);
-        
-        double newSpeed = 1.0;
-        if (masterClockType_ == ClockType::AUDIO) {
-            // 音频为主，调整视频速度
-            newSpeed = videoClock_.speed + speedAdjustment;
-        } else if (masterClockType_ == ClockType::VIDEO) {
-            // 视频为主，调整音频速度
-            newSpeed = audioClock_.speed + speedAdjustment;
-        }
-        
-        // 限制速度范围
-        newSpeed = std::max(0.5, std::min(2.0, newSpeed));
-        
-        if (masterClockType_ == ClockType::AUDIO) {
-            videoClock_.speed = newSpeed;
-        } else if (masterClockType_ == ClockType::VIDEO) {
-            audioClock_.speed = newSpeed;
-        }
-        
-        Logger::instance().debugf("Adjusted playback speed to: {}x", newSpeed);
-    }
-}
-
-void Synchronizer::updateSyncError(double error) {
-    syncErrorHistory_.push_back(error);
-    
-    if (syncErrorHistory_.size() > static_cast<size_t>(config_.smoothingWindow)) {
-        syncErrorHistory_.erase(syncErrorHistory_.begin());
-    }
-}
-
-void Synchronizer::updateDropCount() {
-    std::lock_guard<std::mutex> lock(statsMutex_);
-    stats_.dropCount++;
-}
-
-void Synchronizer::updateDuplicateCount() {
-    std::lock_guard<std::mutex> lock(statsMutex_);
-    stats_.duplicateCount++;
-}
-
-// 多流同步器实现
-MultiStreamSynchronizer::MultiStreamSynchronizer(const SyncConfig& config)
-    : defaultConfig_(config)
-    , masterStreamIndex_(-1)
-    , globalState_(SyncState::IDLE) {
-    Logger::instance().debug("MultiStreamSynchronizer created");
-}
-
-MultiStreamSynchronizer::~MultiStreamSynchronizer() {
-    streamSynchronizers_.clear();
-    Logger::instance().debug("MultiStreamSynchronizer destroyed");
-}
-
-ErrorCode MultiStreamSynchronizer::addStream(int streamIndex, ClockType type) {
-    std::unique_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    if (streamSynchronizers_.find(streamIndex) != streamSynchronizers_.end()) {
-        Logger::instance().warningf("Stream {} already exists", streamIndex);
-        return ErrorCode::ALREADY_EXISTS;
-    }
-    
-    auto synchronizer = std::make_unique<Synchronizer>(defaultConfig_);
-    synchronizer->initialize();
-    
-    streamSynchronizers_[streamIndex] = std::move(synchronizer);
-    streamTypes_[streamIndex] = type;
-    
-    // 如果是第一个流，设为主流
-    if (masterStreamIndex_ == -1) {
-        masterStreamIndex_ = streamIndex;
-    }
-    
-    Logger::instance().debugf("Added stream: {} with type: {}", streamIndex, static_cast<int>(type));
-    return ErrorCode::SUCCESS;
-}
-
-ErrorCode MultiStreamSynchronizer::removeStream(int streamIndex) {
-    std::unique_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    auto it = streamSynchronizers_.find(streamIndex);
-    if (it == streamSynchronizers_.end()) {
-        Logger::instance().warningf("Stream {} not found", streamIndex);
-        return ErrorCode::NOT_FOUND;
-    }
-    
-    streamSynchronizers_.erase(it);
-    streamTypes_.erase(streamIndex);
-    
-    // 如果删除的是主流，重新选择主流
-    if (masterStreamIndex_ == streamIndex) {
-        updateMasterStream();
-    }
-    
-    Logger::instance().debugf("Removed stream: {}", streamIndex);
-    return ErrorCode::SUCCESS;
-}
-
-bool MultiStreamSynchronizer::hasStream(int streamIndex) const {
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    return streamSynchronizers_.find(streamIndex) != streamSynchronizers_.end();
-}
-
-std::vector<int> MultiStreamSynchronizer::getStreamIndices() const {
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    std::vector<int> indices;
-    for (const auto& pair : streamSynchronizers_) {
-        indices.push_back(pair.first);
-    }
-    
-    return indices;
-}
-
-ErrorCode MultiStreamSynchronizer::synchronizeStream(int streamIndex, double pts, double& delay) {
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    auto it = streamSynchronizers_.find(streamIndex);
-    if (it == streamSynchronizers_.end()) {
-        return ErrorCode::NOT_FOUND;
-    }
-    
-    auto typeIt = streamTypes_.find(streamIndex);
-    if (typeIt == streamTypes_.end()) {
-        return ErrorCode::NOT_FOUND;
-    }
-    
-    ClockType type = typeIt->second;
-    
-    if (type == ClockType::AUDIO) {
-        return it->second->synchronizeAudio(pts, delay);
-    } else if (type == ClockType::VIDEO) {
-        return it->second->synchronizeVideo(pts, delay);
-    }
-    
-    return ErrorCode::INVALID_PARAMS;
-}
-
-ErrorCode MultiStreamSynchronizer::synchronizeAllStreams() {
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    ErrorCode result = ErrorCode::SUCCESS;
-    
-    for (auto& pair : streamSynchronizers_) {
-        ErrorCode syncResult = pair.second->synchronize();
-        if (syncResult != ErrorCode::SUCCESS) {
-            result = syncResult;
-        }
-    }
-    
-    // 同步到主流
-    syncToMaster();
-    
-    return result;
-}
-
-bool MultiStreamSynchronizer::shouldDropFrame(int streamIndex, double pts) {
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    auto it = streamSynchronizers_.find(streamIndex);
-    if (it == streamSynchronizers_.end()) {
-        return false;
-    }
-    
-    auto typeIt = streamTypes_.find(streamIndex);
-    if (typeIt == streamTypes_.end()) {
-        return false;
-    }
-    
-    return it->second->shouldDropFrame(typeIt->second, pts);
-}
-
-bool MultiStreamSynchronizer::shouldDuplicateFrame(int streamIndex, double pts) {
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    auto it = streamSynchronizers_.find(streamIndex);
-    if (it == streamSynchronizers_.end()) {
-        return false;
-    }
-    
-    auto typeIt = streamTypes_.find(streamIndex);
-    if (typeIt == streamTypes_.end()) {
-        return false;
-    }
-    
-    return it->second->shouldDuplicateFrame(typeIt->second, pts);
-}
-
-ErrorCode MultiStreamSynchronizer::updateStreamClock(int streamIndex, double pts, double time) {
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    auto it = streamSynchronizers_.find(streamIndex);
-    if (it == streamSynchronizers_.end()) {
-        return ErrorCode::NOT_FOUND;
-    }
-    
-    auto typeIt = streamTypes_.find(streamIndex);
-    if (typeIt == streamTypes_.end()) {
-        return ErrorCode::NOT_FOUND;
-    }
-    
-    return it->second->updateClock(typeIt->second, pts, time);
-}
-
-double MultiStreamSynchronizer::getStreamClock(int streamIndex) const {
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    auto it = streamSynchronizers_.find(streamIndex);
-    if (it == streamSynchronizers_.end()) {
-        return 0.0;
-    }
-    
-    return it->second->getMasterClock();
-}
-
-double MultiStreamSynchronizer::getMasterClock() const {
-    std::lock_guard<std::mutex> lock(masterMutex_);
-    
-    if (masterStreamIndex_ == -1) {
-        return 0.0;
-    }
-    
-    return getStreamClock(masterStreamIndex_);
-}
-
-int MultiStreamSynchronizer::getMasterStreamIndex() const {
-    std::lock_guard<std::mutex> lock(masterMutex_);
-    return masterStreamIndex_;
-}
-
-void MultiStreamSynchronizer::setConfig(const SyncConfig& config) {
-    defaultConfig_ = config;
-    
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    for (auto& pair : streamSynchronizers_) {
-        pair.second->setConfig(config);
-    }
-    
-    Logger::instance().debug("MultiStreamSynchronizer config updated");
-}
-
-SyncConfig MultiStreamSynchronizer::getConfig() const {
-    return defaultConfig_;
-}
-
-SyncState MultiStreamSynchronizer::getState() const {
-    return globalState_;
-}
-
-std::map<int, SyncStats> MultiStreamSynchronizer::getAllStats() const {
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    std::map<int, SyncStats> allStats;
-    for (const auto& pair : streamSynchronizers_) {
-        allStats[pair.first] = pair.second->getStats();
-    }
-    
-    return allStats;
-}
-
-SyncStats MultiStreamSynchronizer::getStats(int streamIndex) const {
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    auto it = streamSynchronizers_.find(streamIndex);
-    if (it != streamSynchronizers_.end()) {
-        return it->second->getStats();
-    }
-    
-    return SyncStats();
-}
-
-void MultiStreamSynchronizer::resetStats() {
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    for (auto& pair : streamSynchronizers_) {
-        pair.second->resetStats();
-    }
-    
-    Logger::instance().debug("All stream synchronizer stats reset");
-}
-
-void MultiStreamSynchronizer::resetStats(int streamIndex) {
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    auto it = streamSynchronizers_.find(streamIndex);
-    if (it != streamSynchronizers_.end()) {
-        it->second->resetStats();
-        Logger::instance().debugf("Stream {} synchronizer stats reset", streamIndex);
-    }
-}
-
-ErrorCode MultiStreamSynchronizer::start() {
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    ErrorCode result = ErrorCode::SUCCESS;
-    
-    for (auto& pair : streamSynchronizers_) {
-        ErrorCode startResult = pair.second->start();
-        if (startResult != ErrorCode::SUCCESS) {
-            result = startResult;
-        }
-    }
-    
-    globalState_ = SyncState::SYNCING;
-    
-    Logger::instance().info("MultiStreamSynchronizer started");
-    return result;
-}
-
-ErrorCode MultiStreamSynchronizer::stop() {
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    ErrorCode result = ErrorCode::SUCCESS;
-    
-    for (auto& pair : streamSynchronizers_) {
-        ErrorCode stopResult = pair.second->stop();
-        if (stopResult != ErrorCode::SUCCESS) {
-            result = stopResult;
-        }
-    }
-    
-    globalState_ = SyncState::IDLE;
-    
-    Logger::instance().info("MultiStreamSynchronizer stopped");
-    return result;
-}
-
-ErrorCode MultiStreamSynchronizer::pause() {
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    ErrorCode result = ErrorCode::SUCCESS;
-    
-    for (auto& pair : streamSynchronizers_) {
-        ErrorCode pauseResult = pair.second->pause();
-        if (pauseResult != ErrorCode::SUCCESS) {
-            result = pauseResult;
-        }
-    }
-    
-    Logger::instance().info("MultiStreamSynchronizer paused");
-    return result;
-}
-
-ErrorCode MultiStreamSynchronizer::resume() {
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    ErrorCode result = ErrorCode::SUCCESS;
-    
-    for (auto& pair : streamSynchronizers_) {
-        ErrorCode resumeResult = pair.second->resume();
-        if (resumeResult != ErrorCode::SUCCESS) {
-            result = resumeResult;
-        }
-    }
-    
-    globalState_ = SyncState::SYNCING;
-    
-    Logger::instance().info("MultiStreamSynchronizer resumed");
-    return result;
-}
-
-ErrorCode MultiStreamSynchronizer::reset() {
-    std::shared_lock<std::shared_mutex> lock(streamsMutex_);
-    
-    ErrorCode result = ErrorCode::SUCCESS;
-    
-    for (auto& pair : streamSynchronizers_) {
-        ErrorCode resetResult = pair.second->reset();
-        if (resetResult != ErrorCode::SUCCESS) {
-            result = resetResult;
-        }
-    }
-    
-    Logger::instance().info("MultiStreamSynchronizer reset");
-    return result;
-}
-
-void MultiStreamSynchronizer::updateMasterStream() {
-    std::lock_guard<std::mutex> lock(masterMutex_);
-    
-    if (streamSynchronizers_.empty()) {
-        masterStreamIndex_ = -1;
-        return;
-    }
-    
-    // 选择第一个音频流作为主流，如果没有音频流则选择第一个视频流
-    for (const auto& pair : streamTypes_) {
-        if (pair.second == ClockType::AUDIO) {
-            masterStreamIndex_ = pair.first;
-            return;
-        }
-    }
-    
-    // 如果没有音频流，选择第一个流
-    masterStreamIndex_ = streamSynchronizers_.begin()->first;
-}
-
-void MultiStreamSynchronizer::syncToMaster() {
-    if (masterStreamIndex_ == -1) {
-        return;
-    }
-    
-    double masterClock = getMasterClock();
-    
-    // 将其他流同步到主流
-    for (auto& pair : streamSynchronizers_) {
-        if (pair.first != masterStreamIndex_) {
-            // 这里可以实现更复杂的同步逻辑
-            // 暂时简化处理
-        }
-    }
-}
-
-// 工厂类实现
-std::unique_ptr<Synchronizer> SynchronizerFactory::createStandardSynchronizer() {
-    SyncConfig config;
-    config.strategy = SyncStrategy::AUDIO_MASTER;
-    config.maxAudioDelay = 0.1;
-    config.maxVideoDelay = 0.04;
-    config.syncThreshold = 0.01;
-    config.enableFrameDrop = true;
-    config.enableFrameDuplicate = true;
-    config.enableAdaptiveSync = true;
-    
-    return std::make_unique<Synchronizer>(config);
-}
-
-std::unique_ptr<Synchronizer> SynchronizerFactory::createLowLatencySynchronizer() {
-    SyncConfig config;
-    config.strategy = SyncStrategy::AUTO_SELECT;
-    config.maxAudioDelay = 0.05;
-    config.maxVideoDelay = 0.02;
-    config.syncThreshold = 0.005;
-    config.maxSyncError = 0.1;
-    config.enableFrameDrop = true;
-    config.enableFrameDuplicate = false;
-    config.enableAdaptiveSync = true;
-    config.smoothingWindow = 5;
-    
-    return std::make_unique<Synchronizer>(config);
-}
-
-std::unique_ptr<Synchronizer> SynchronizerFactory::createHighPrecisionSynchronizer() {
-    SyncConfig config;
-    config.strategy = SyncStrategy::EXTERNAL_CLOCK;
-    config.maxAudioDelay = 0.2;
-    config.maxVideoDelay = 0.08;
-    config.syncThreshold = 0.001;
-    config.maxSyncError = 0.01;
-    config.enableFrameDrop = true;
-    config.enableFrameDuplicate = true;
-    config.enableAdaptiveSync = true;
-    config.smoothingWindow = 20;
-    config.clockUpdateInterval = 0.01;
-    
-    return std::make_unique<Synchronizer>(config);
-}
-
-std::unique_ptr<Synchronizer> SynchronizerFactory::createRealtimeSynchronizer() {
-    SyncConfig config;
-    config.strategy = SyncStrategy::VIDEO_MASTER;
-    config.maxAudioDelay = 0.03;
-    config.maxVideoDelay = 0.016;
-    config.syncThreshold = 0.008;
-    config.maxSyncError = 0.05;
-    config.enableFrameDrop = true;
-    config.enableFrameDuplicate = false;
-    config.enableAdaptiveSync = true;
-    config.smoothingWindow = 3;
-    config.clockUpdateInterval = 0.016;
-    
-    return std::make_unique<Synchronizer>(config);
-}
-
-std::unique_ptr<MultiStreamSynchronizer> SynchronizerFactory::createMultiStreamSynchronizer(const SyncConfig& config) {
-    return std::make_unique<MultiStreamSynchronizer>(config);
-}
-
-} // namespace utils
-} // namespace av

AV/code/utils/utils_synchronizer.h

@@ -1,307 +0,0 @@
-#pragma once
-
-#include "../base/types.h"
-#include <memory>
-#include <chrono>
-#include <functional>
-#include <atomic>
-#include <mutex>
-#include <shared_mutex>
-#include <condition_variable>
-#include <map>
-#include <vector>
-
-extern "C" {
-#include <libavformat/avformat.h>
-#include <libavutil/time.h>
-}
-
-namespace av {
-namespace utils {
-
-using namespace av;
-
-// 同步策略
-enum class SyncStrategy {
-    AUDIO_MASTER,    // 以音频为主
-    VIDEO_MASTER,    // 以视频为主
-    EXTERNAL_CLOCK,  // 外部时钟
-    AUTO_SELECT      // 自动选择
-};
-
-// 同步状态
-enum class SyncState {
-    NOT_STARTED,    // 未开始
-    IDLE,           // 空闲
-    SYNCING,        // 同步中
-    SYNCHRONIZED,   // 已同步
-    DRIFT,          // 时钟漂移
-    ERROR           // 错误
-};
-
-// 时钟类型
-enum class ClockType {
-    AUDIO,
-    VIDEO,
-    EXTERNAL
-};
-
-// 同步统计信息
-struct SyncStats {
-    double audioClock = 0.0;           // 音频时钟
-    double videoClock = 0.0;           // 视频时钟
-    double externalClock = 0.0;        // 外部时钟
-    double masterClock = 0.0;          // 主时钟
-    double audioDelay = 0.0;           // 音频延迟
-    double videoDelay = 0.0;           // 视频延迟
-    double syncError = 0.0;            // 同步误差
-    double maxSyncError = 0.0;         // 最大同步误差
-    double avgSyncError = 0.0;         // 平均同步误差
-    uint64_t syncCount = 0;            // 同步次数
-    uint64_t dropCount = 0;            // 丢帧次数
-    uint64_t duplicateCount = 0;       // 重复帧次数
-    SyncState state = SyncState::IDLE; // 同步状态
-    std::chrono::steady_clock::time_point lastUpdateTime; // 最后更新时间
-};
-
-// 同步配置
-struct SyncConfig {
-    SyncStrategy strategy = SyncStrategy::AUDIO_MASTER;  // 同步策略
-    double maxAudioDelay = 0.1;        // 最大音频延迟(秒)
-    double maxVideoDelay = 0.04;       // 最大视频延迟(秒)
-    double syncThreshold = 0.01;       // 同步阈值(秒)
-    double maxSyncError = 1.0;         // 最大同步误差(秒)
-    bool enableFrameDrop = true;       // 启用丢帧
-    bool enableFrameDuplicate = true;  // 启用重复帧
-    bool enableAdaptiveSync = true;    // 启用自适应同步
-    bool enableStats = true;           // 启用统计
-    int smoothingWindow = 10;          // 平滑窗口大小
-    double clockUpdateInterval = 0.1;  // 时钟更新间隔(秒)
-};
-
-// 时钟信息
-struct ClockInfo {
-    double pts = 0.0;                  // 显示时间戳
-    double time = 0.0;                 // 系统时间
-    double speed = 1.0;                // 播放速度
-    bool paused = false;               // 是否暂停
-    std::chrono::steady_clock::time_point lastUpdate; // 最后更新时间
-};
-
-// 同步事件回调
-using SyncEventCallback = std::function<void(SyncState state, double error)>;
-using FrameDropCallback = std::function<void(ClockType type, double pts)>;
-using FrameDuplicateCallback = std::function<void(ClockType type, double pts)>;
-
-// 音视频同步器
-class Synchronizer {
-public:
-    explicit Synchronizer(const SyncConfig& config = SyncConfig());
-    virtual ~Synchronizer();
-
-    // 基本控制
-    ErrorCode initialize();
-    ErrorCode start();
-    ErrorCode stop();
-    ErrorCode pause();
-    ErrorCode resume();
-    ErrorCode reset();
-    ErrorCode close();
-
-    // 时钟管理
-    ErrorCode setAudioClock(double pts, double time = -1);
-    ErrorCode setVideoClock(double pts, double time = -1);
-    ErrorCode setExternalClock(double time);
-    ErrorCode updateClock(ClockType type, double pts, double time = -1);
-    
-    double getAudioClock() const;
-    double getVideoClock() const;
-    double getExternalClock() const;
-    double getMasterClock() const;
-    ClockType getMasterClockType() const;
-    
-    // 同步控制
-    ErrorCode synchronize();
-    ErrorCode synchronizeAudio(double audioPts, double& delay);
-    ErrorCode synchronizeVideo(double videoPts, double& delay);
-    bool shouldDropFrame(ClockType type, double pts);
-    bool shouldDuplicateFrame(ClockType type, double pts);
-    
-    // 延迟计算
-    double calculateAudioDelay(double audioPts) const;
-    double calculateVideoDelay(double videoPts) const;
-    double calculateSyncError() const;
-    
-    // 配置管理
-    void setConfig(const SyncConfig& config);
-    SyncConfig getConfig() const;
-    void setSyncStrategy(SyncStrategy strategy);
-    SyncStrategy getSyncStrategy() const;
-    void setSyncThreshold(double threshold);
-    void setMaxSyncError(double maxError);
-    
-    // 播放控制
-    void setPlaybackSpeed(double speed);
-    double getPlaybackSpeed() const;
-    void setPaused(bool paused);
-    bool isPaused() const;
-    
-    // 状态查询
-    SyncState getState() const;
-    bool isSynchronized() const;
-    SyncStats getStats() const;
-    void resetStats();
-    
-    // 回调设置
-    void setSyncEventCallback(SyncEventCallback callback);
-    void setFrameDropCallback(FrameDropCallback callback);
-    void setFrameDuplicateCallback(FrameDuplicateCallback callback);
-    
-    // 高级功能
-    void enableAdaptiveSync(bool enable);
-    void setClockUpdateInterval(double interval);
-    void setSmoothingWindow(int window);
-    
-private:
-    // 内部方法
-    void updateMasterClock();
-    void updateSyncState();
-    void updateStats();
-    double getCurrentTime() const;
-    double smoothClock(ClockType type, double newValue);
-    bool isClockValid(ClockType type) const;
-    void selectMasterClock();
-    void handleSyncDrift();
-    void notifyStateChange(SyncState newState);
-    
-    // 时钟相关
-    double getClockValue(ClockType type) const;
-    void setClockValue(ClockType type, double value, double time = -1);
-    void resetClock(ClockType type);
-    void pauseClock(ClockType type, bool pause);
-    
-    // 同步算法
-    double calculateOptimalDelay(ClockType type, double pts);
-    bool needFrameDrop(ClockType type, double pts);
-    bool needFrameDuplicate(ClockType type, double pts);
-    void adjustPlaybackSpeed();
-    
-    // 统计更新
-    void updateSyncError(double error);
-    void updateDropCount();
-    void updateDuplicateCount();
-    
-private:
-    SyncConfig config_;
-    
-    // 时钟信息
-    ClockInfo audioClock_;
-    ClockInfo videoClock_;
-    ClockInfo externalClock_;
-    ClockType masterClockType_;
-    
-    // 同步状态
-    std::atomic<SyncState> state_;
-    std::atomic<bool> initialized_;
-    std::atomic<bool> running_;
-    std::atomic<bool> paused_;
-    
-    // 统计信息
-    SyncStats stats_;
-    mutable std::mutex statsMutex_;
-    
-    // 平滑处理
-    std::vector<double> audioClockHistory_;
-    std::vector<double> videoClockHistory_;
-    std::vector<double> syncErrorHistory_;
-    
-    // 回调函数
-    SyncEventCallback syncEventCallback_;
-    FrameDropCallback frameDropCallback_;
-    FrameDuplicateCallback frameDuplicateCallback_;
-    
-    // 线程同步
-    mutable std::mutex clockMutex_;
-    mutable std::mutex configMutex_;
-    
-    // 时间相关
-    std::chrono::steady_clock::time_point startTime_;
-    std::chrono::steady_clock::time_point lastClockUpdate_;
-};
-
-// 多流同步器
-class MultiStreamSynchronizer {
-public:
-    explicit MultiStreamSynchronizer(const SyncConfig& config = SyncConfig());
-    virtual ~MultiStreamSynchronizer();
-
-    // 流管理
-    ErrorCode addStream(int streamIndex, ClockType type);
-    ErrorCode removeStream(int streamIndex);
-    bool hasStream(int streamIndex) const;
-    std::vector<int> getStreamIndices() const;
-    
-    // 同步控制
-    ErrorCode synchronizeStream(int streamIndex, double pts, double& delay);
-    ErrorCode synchronizeAllStreams();
-    bool shouldDropFrame(int streamIndex, double pts);
-    bool shouldDuplicateFrame(int streamIndex, double pts);
-    
-    // 时钟管理
-    ErrorCode updateStreamClock(int streamIndex, double pts, double time = -1);
-    double getStreamClock(int streamIndex) const;
-    double getMasterClock() const;
-    int getMasterStreamIndex() const;
-    
-    // 配置和状态
-    void setConfig(const SyncConfig& config);
-    SyncConfig getConfig() const;
-    SyncState getState() const;
-    std::map<int, SyncStats> getAllStats() const;
-    SyncStats getStats(int streamIndex) const;
-    void resetStats();
-    void resetStats(int streamIndex);
-    
-    // 控制
-    ErrorCode start();
-    ErrorCode stop();
-    ErrorCode pause();
-    ErrorCode resume();
-    ErrorCode reset();
-    
-private:
-    SyncConfig defaultConfig_;
-    std::map<int, std::unique_ptr<Synchronizer>> streamSynchronizers_;
-    std::map<int, ClockType> streamTypes_;
-    
-    int masterStreamIndex_;
-    std::atomic<SyncState> globalState_;
-    
-    mutable std::shared_mutex streamsMutex_;
-    mutable std::mutex masterMutex_;
-    
-    void updateMasterStream();
-    void syncToMaster();
-};
-
-// 同步器工厂
-class SynchronizerFactory {
-public:
-    // 创建标准同步器
-    static std::unique_ptr<Synchronizer> createStandardSynchronizer();
-    
-    // 创建低延迟同步器
-    static std::unique_ptr<Synchronizer> createLowLatencySynchronizer();
-    
-    // 创建高精度同步器
-    static std::unique_ptr<Synchronizer> createHighPrecisionSynchronizer();
-    
-    // 创建实时同步器
-    static std::unique_ptr<Synchronizer> createRealtimeSynchronizer();
-    
-    // 创建多流同步器
-    static std::unique_ptr<MultiStreamSynchronizer> createMultiStreamSynchronizer(const SyncConfig& config = SyncConfig());
-};
-
-} // namespace utils
-} // namespace av

AV/code/utils/utils_synchronizer_v2.cpp

@@ -0,0 +1,1033 @@
+#include "utils_synchronizer_v2.h"
+#include "../base/logger.h"
+#include <algorithm>
+#include <cmath>
+#include <sstream>
+#include <iomanip>
+
+namespace av {
+namespace utils {
+
+SynchronizerV2::SynchronizerV2(const SyncConfigV2& config)
+    : config_(config)
+    , masterClockType_(ClockType::AUDIO)
+    , state_(SyncState::IDLE)
+    , initialized_(false)
+    , running_(false)
+    , paused_(false)
+    , recoveryAttempts_(0)
+    , lastSyncError_(0.0) {
+    
+    // 初始化时钟
+    audioClock_ = ClockInfo();
+    videoClock_ = ClockInfo();
+    externalClock_ = ClockInfo();
+    
+    // 初始化历史记录
+    audioClockHistory_.clear();
+    videoClockHistory_.clear();
+    syncErrorHistory_.clear();
+    
+    Logger::instance().info("SynchronizerV2 created with strategy: " + 
+                           std::to_string(static_cast<int>(config_.strategy)));
+}
+
+SynchronizerV2::~SynchronizerV2() {
+    close();
+    Logger::instance().info("SynchronizerV2 destroyed");
+}
+
+ErrorCode SynchronizerV2::initialize() {
+    if (initialized_) {
+        return ErrorCode::ALREADY_INITIALIZED;
+    }
+    
+    std::lock_guard<std::mutex> clockLock(clockMutex_);
+    std::lock_guard<std::mutex> statsLock(statsMutex_);
+    
+    // 重置所有时钟
+    resetClock(ClockType::AUDIO);
+    resetClock(ClockType::VIDEO);
+    resetClock(ClockType::EXTERNAL);
+    
+    // 选择主时钟
+    selectMasterClock();
+    
+    // 重置统计信息
+    stats_ = SyncStatsV2();
+    stats_.lastUpdateTime = std::chrono::steady_clock::now();
+    
+    // 设置开始时间
+    startTime_ = std::chrono::steady_clock::now();
+    lastClockUpdate_ = startTime_;
+    lastStatsUpdate_ = startTime_;
+    
+    state_ = SyncState::IDLE;
+    initialized_ = true;
+    recoveryAttempts_ = 0;
+    
+    Logger::instance().info("SynchronizerV2 initialized");
+    return ErrorCode::SUCCESS;
+}
+
+ErrorCode SynchronizerV2::start() {
+    if (!initialized_) {
+        return ErrorCode::NOT_INITIALIZED;
+    }
+    
+    if (running_) {
+        return ErrorCode::ALREADY_STARTED;
+    }
+    
+    running_ = true;
+    paused_ = false;
+    state_ = SyncState::INITIALIZING;
+    
+    startTime_ = std::chrono::steady_clock::now();
+    lastClockUpdate_ = startTime_;
+    
+    // 启动后立即进入同步状态
+    state_ = SyncState::SYNCING;
+    
+    Logger::instance().info("SynchronizerV2 started");
+    return ErrorCode::SUCCESS;
+}
+
+void SynchronizerV2::setStreamInfo(bool hasAudio, bool hasVideo) {
+    std::lock_guard<std::mutex> lock(clockMutex_);
+    hasAudioStream_ = hasAudio;
+    hasVideoStream_ = hasVideo;
+    
+    Logger::instance().info("Stream info updated: hasAudio=" + std::to_string(hasAudio) + 
+                           ", hasVideo=" + std::to_string(hasVideo));
+    
+    // 重新选择主时钟
+    selectMasterClock();
+}
+
+ErrorCode SynchronizerV2::stop() {
+    if (!running_) {
+        return ErrorCode::NOT_STARTED;
+    }
+    
+    running_ = false;
+    paused_ = false;
+    state_ = SyncState::IDLE;
+    
+    Logger::instance().info("SynchronizerV2 stopped");
+    return ErrorCode::SUCCESS;
+}
+
+ErrorCode SynchronizerV2::pause() {
+    if (!running_) {
+        return ErrorCode::NOT_STARTED;
+    }
+    
+    if (paused_) {
+        return ErrorCode::ALREADY_PAUSED;
+    }
+    
+    std::lock_guard<std::mutex> lock(clockMutex_);
+    
+    paused_ = true;
+    
+    // 暂停所有时钟
+    pauseClock(ClockType::AUDIO, true);
+    pauseClock(ClockType::VIDEO, true);
+    pauseClock(ClockType::EXTERNAL, true);
+    
+    Logger::instance().info("SynchronizerV2 paused");
+    return ErrorCode::SUCCESS;
+}
+
+ErrorCode SynchronizerV2::resume() {
+    if (!running_) {
+        return ErrorCode::NOT_STARTED;
+    }
+    
+    if (!paused_) {
+        return ErrorCode::NOT_PAUSED;
+    }
+    
+    std::lock_guard<std::mutex> lock(clockMutex_);
+    
+    paused_ = false;
+    
+    // 恢复所有时钟
+    pauseClock(ClockType::AUDIO, false);
+    pauseClock(ClockType::VIDEO, false);
+    pauseClock(ClockType::EXTERNAL, false);
+    
+    state_ = SyncState::SYNCING;
+    
+    Logger::instance().info("SynchronizerV2 resumed");
+    return ErrorCode::SUCCESS;
+}
+
+ErrorCode SynchronizerV2::reset() {
+    std::lock_guard<std::mutex> clockLock(clockMutex_);
+    std::lock_guard<std::mutex> statsLock(statsMutex_);
+    std::lock_guard<std::mutex> historyLock(historyMutex_);
+    
+    // 重置时钟
+    resetClock(ClockType::AUDIO);
+    resetClock(ClockType::VIDEO);
+    resetClock(ClockType::EXTERNAL);
+    
+    // 重置统计信息
+    stats_ = SyncStatsV2();
+    stats_.lastUpdateTime = std::chrono::steady_clock::now();
+    
+    // 清空历史记录
+    audioClockHistory_.clear();
+    videoClockHistory_.clear();
+    syncErrorHistory_.clear();
+    
+    // 重置状态
+    state_ = running_ ? SyncState::SYNCING : SyncState::IDLE;
+    recoveryAttempts_ = 0;
+    lastSyncError_ = 0.0;
+    
+    // 重新选择主时钟
+    selectMasterClock();
+    
+    Logger::instance().info("SynchronizerV2 reset");
+    return ErrorCode::SUCCESS;
+}
+
+ErrorCode SynchronizerV2::close() {
+    if (running_) {
+        stop();
+    }
+    
+    initialized_ = false;
+    
+    Logger::instance().info("SynchronizerV2 closed");
+    return ErrorCode::SUCCESS;
+}
+
+ErrorCode SynchronizerV2::setAudioClock(double pts, double time, int serial) {
+    return updateClock(ClockType::AUDIO, pts, time, serial);
+}
+
+ErrorCode SynchronizerV2::setVideoClock(double pts, double time, int serial) {
+    return updateClock(ClockType::VIDEO, pts, time, serial);
+}
+
+ErrorCode SynchronizerV2::setExternalClock(double time, int serial) {
+    if (time < 0) {
+        time = getCurrentTime();
+    }
+    return updateClock(ClockType::EXTERNAL, time, time, serial);
+}
+
+double SynchronizerV2::getAudioClock(bool predict) const {
+    return getClock(ClockType::AUDIO, predict);
+}
+
+double SynchronizerV2::getVideoClock(bool predict) const {
+    return getClock(ClockType::VIDEO, predict);
+}
+
+double SynchronizerV2::getExternalClock(bool predict) const {
+    return getClock(ClockType::EXTERNAL, predict);
+}
+
+double SynchronizerV2::getMasterClock(bool predict) const {
+    return getClock(masterClockType_, predict);
+}
+
+FrameDecision SynchronizerV2::shouldDisplayVideoFrame(double pts, double duration) {
+    FrameDecision decision;
+    decision.actualPts = pts;
+    
+    if (!running_ || paused_) {
+        decision.action = FrameAction::DELAY;
+        decision.delay = 0.01; // 10ms
+        decision.reason = paused_ ? "Paused" : "Not running";
+        return decision;
+    }
+    
+    // 获取主时钟
+    double masterClock = getMasterClock(true); // 使用预测
+    decision.targetPts = masterClock;
+    
+    // 计算同步误差
+    double syncError = pts - masterClock;
+    decision.syncError = syncError;
+    
+    // 如果视频是主时钟，直接显示
+    if (masterClockType_ == ClockType::VIDEO) {
+        decision.action = FrameAction::DISPLAY;
+        decision.delay = duration > 0 ? duration : (1.0 / 25.0); // 默认25fps
+        decision.reason = "Video master";
+        return decision;
+    }
+    
+    // 根据同步误差决定动作
+    if (syncError < -config_.frameDropThreshold) {
+        // 视频太慢，丢帧
+        decision.action = FrameAction::DROP;
+        decision.reason = "Video too slow, drop frame";
+        
+        // 通知丢帧
+        if (frameDropCallback_) {
+            frameDropCallback_(ClockType::VIDEO, pts);
+        }
+        
+        // 更新统计
+        std::lock_guard<std::mutex> lock(statsMutex_);
+        stats_.droppedFrames++;
+        
+    } else if (syncError > config_.frameDupThreshold) {
+        // 视频太快，重复帧或延迟
+        if (duration > 0 && syncError < config_.frameDupThreshold * 2) {
+            decision.action = FrameAction::DELAY;
+            decision.delay = std::min(syncError, config_.maxSyncError);
+            decision.reason = "Video too fast, delay";
+        } else {
+            decision.action = FrameAction::Frame_DUPLICATE;
+            decision.reason = "Video too fast, duplicate frame";
+            
+            // 通知重复帧
+            if (frameDuplicateCallback_) {
+                frameDuplicateCallback_(ClockType::VIDEO, pts);
+            }
+            
+            // 更新统计
+            std::lock_guard<std::mutex> lock(statsMutex_);
+            stats_.duplicatedFrames++;
+        }
+        
+    } else {
+        // 正常显示
+        decision.action = FrameAction::DISPLAY;
+        decision.delay = calculateTargetDelay(pts, ClockType::VIDEO);
+        decision.reason = "Normal display";
+    }
+    
+    // 更新统计
+    {
+        std::lock_guard<std::mutex> lock(statsMutex_);
+        stats_.totalFrames++;
+        stats_.syncError = syncError;
+        
+        // 更新平均同步误差
+        if (stats_.totalFrames == 1) {
+            stats_.avgSyncError = std::abs(syncError);
+        } else {
+            stats_.avgSyncError = stats_.avgSyncError * 0.9 + std::abs(syncError) * 0.1;
+        }
+        
+        // 更新最大同步误差
+        stats_.maxSyncError = std::max(stats_.maxSyncError, std::abs(syncError));
+    }
+    
+    return decision;
+}
+
+FrameDecision SynchronizerV2::shouldPlayAudioFrame(double pts, double duration) {
+    FrameDecision decision;
+    decision.actualPts = pts;
+    
+    if (!running_ || paused_) {
+        decision.action = FrameAction::DELAY;
+        decision.delay = 0.01; // 10ms
+        decision.reason = paused_ ? "Paused" : "Not running";
+        return decision;
+    }
+    
+    // 音频通常作为主时钟，或者需要与主时钟同步
+    if (masterClockType_ == ClockType::AUDIO) {
+        decision.action = FrameAction::DISPLAY;
+        decision.delay = duration > 0 ? duration : 0.023; // 默认23ms (44.1kHz, 1024 samples)
+        decision.reason = "Audio master";
+        decision.targetPts = pts;
+        return decision;
+    }
+    
+    // 与主时钟同步
+    double masterClock = getMasterClock(true);
+    decision.targetPts = masterClock;
+    
+    double syncError = pts - masterClock;
+    decision.syncError = syncError;
+    
+    if (std::abs(syncError) > config_.maxSyncError) {
+        // 同步误差太大，丢弃或延迟
+        if (syncError < 0) {
+            decision.action = FrameAction::DROP;
+            decision.reason = "Audio too slow, drop";
+        } else {
+            decision.action = FrameAction::DELAY;
+            decision.delay = std::min(syncError, config_.maxSyncError);
+            decision.reason = "Audio too fast, delay";
+        }
+    } else {
+        decision.action = FrameAction::DISPLAY;
+        decision.delay = calculateTargetDelay(pts, ClockType::AUDIO);
+        decision.reason = "Normal audio play";
+    }
+    
+    return decision;
+}
+
+double SynchronizerV2::calculateTargetDelay(double pts, ClockType clockType) {
+    if (!running_) {
+        return 0.0;
+    }
+    
+    // 基础延迟
+    double baseDelay = 0.0;
+    if (clockType == ClockType::VIDEO) {
+        baseDelay = 1.0 / 25.0; // 默认25fps
+    } else if (clockType == ClockType::AUDIO) {
+        baseDelay = 0.023; // 默认23ms
+    }
+    
+    // 如果是主时钟，返回基础延迟
+    if (clockType == masterClockType_) {
+        return baseDelay;
+    }
+    
+    // 计算与主时钟的差异
+    double masterClock = getMasterClock(true);
+    double diff = pts - masterClock;
+    
+    // 调整延迟
+    double adjustedDelay = baseDelay;
+    
+    if (std::abs(diff) < config_.syncThreshold) {
+        // 在同步阈值内，正常延迟
+        adjustedDelay = baseDelay;
+    } else if (diff < 0) {
+        // 落后于主时钟，减少延迟
+        adjustedDelay = std::max(0.0, baseDelay + diff);
+    } else {
+        // 超前于主时钟，增加延迟
+        adjustedDelay = baseDelay + std::min(diff, config_.maxSyncError);
+    }
+    
+    return adjustedDelay;
+}
+
+bool SynchronizerV2::shouldDropFrame(double pts, ClockType clockType) {
+    if (!running_ || clockType == masterClockType_) {
+        return false;
+    }
+    
+    double masterClock = getMasterClock();
+    double diff = pts - masterClock;
+    
+    return diff < -config_.frameDropThreshold;
+}
+
+bool SynchronizerV2::shouldDuplicateFrame(double pts, ClockType clockType) {
+    if (!running_ || clockType == masterClockType_) {
+        return false;
+    }
+    
+    double masterClock = getMasterClock();
+    double diff = pts - masterClock;
+    
+    return diff > config_.frameDupThreshold;
+}
+
+double SynchronizerV2::calculateSyncError() const {
+    if (!running_) {
+        return 0.0;
+    }
+    
+    double audioClock = getAudioClock();
+    double videoClock = getVideoClock();
+    
+    if (audioClock <= 0 || videoClock <= 0) {
+        return 0.0;
+    }
+    
+    return std::abs(audioClock - videoClock);
+}
+
+// 内部版本，假设调用者已经持有clockMutex_锁
+double SynchronizerV2::calculateSyncErrorInternal() const {
+    if (!running_) {
+        return 0.0;
+    }
+    
+    // 直接计算时钟值，避免调用getClock导致死锁
+    double audioClock = 0.0;
+    double videoClock = 0.0;
+    
+    // 计算音频时钟
+    if (!audioClock_.paused) {
+        auto now = std::chrono::steady_clock::now();
+        double elapsed = std::chrono::duration<double>(now - audioClock_.lastUpdate).count();
+        audioClock = audioClock_.pts + elapsed * audioClock_.speed;
+    } else {
+        audioClock = audioClock_.pts;
+    }
+    
+    // 计算视频时钟
+    if (!videoClock_.paused) {
+        auto now = std::chrono::steady_clock::now();
+        double elapsed = std::chrono::duration<double>(now - videoClock_.lastUpdate).count();
+        videoClock = videoClock_.pts + elapsed * videoClock_.speed;
+    } else {
+        videoClock = videoClock_.pts;
+    }
+    
+    if (audioClock <= 0 || videoClock <= 0) {
+        return 0.0;
+    }
+    
+    return std::abs(audioClock - videoClock);
+}
+
+double SynchronizerV2::calculateAudioDelay(double pts) const {
+    if (masterClockType_ == ClockType::AUDIO) {
+        return 0.0;
+    }
+    
+    double masterClock = getMasterClock();
+    return pts - masterClock;
+}
+
+double SynchronizerV2::calculateVideoDelay(double pts) const {
+    if (masterClockType_ == ClockType::VIDEO) {
+        return 0.0;
+    }
+    
+    double masterClock = getMasterClock();
+    return pts - masterClock;
+}
+
+void SynchronizerV2::setConfig(const SyncConfigV2& config) {
+    std::lock_guard<std::mutex> lock(configMutex_);
+    config_ = config;
+    
+    // 重新选择主时钟
+    selectMasterClock();
+    
+    Logger::instance().info("SynchronizerV2 config updated");
+}
+
+SyncConfigV2 SynchronizerV2::getConfig() const {
+    std::lock_guard<std::mutex> lock(configMutex_);
+    return config_;
+}
+
+void SynchronizerV2::setSyncStrategy(SyncStrategy strategy) {
+    std::lock_guard<std::mutex> lock(configMutex_);
+    config_.strategy = strategy;
+    selectMasterClock();
+    
+    Logger::instance().info("Sync strategy set to: " + std::to_string(static_cast<int>(strategy)));
+}
+
+SyncStrategy SynchronizerV2::getSyncStrategy() const {
+    std::lock_guard<std::mutex> lock(configMutex_);
+    return config_.strategy;
+}
+
+void SynchronizerV2::setPlaybackSpeed(double speed) {
+    std::lock_guard<std::mutex> lock(clockMutex_);
+    
+    audioClock_.speed = speed;
+    videoClock_.speed = speed;
+    externalClock_.speed = speed;
+    
+    Logger::instance().info("Playback speed set to: " + std::to_string(speed) + "x");
+}
+
+double SynchronizerV2::getPlaybackSpeed() const {
+    std::lock_guard<std::mutex> lock(clockMutex_);
+    return audioClock_.speed;
+}
+
+bool SynchronizerV2::isSynchronized() const {
+    return state_ == SyncState::SYNCHRONIZED;
+}
+
+SyncStatsV2 SynchronizerV2::getStats() const {
+    std::lock_guard<std::mutex> lock(statsMutex_);
+    SyncStatsV2 stats = stats_;
+    
+    // 更新当前时钟值
+    stats.audioClock = getAudioClock();
+    stats.videoClock = getVideoClock();
+    stats.externalClock = getExternalClock();
+    stats.masterClock = getMasterClock();
+    stats.state = state_;
+    stats.masterClockType = masterClockType_;
+    
+    return stats;
+}
+
+void SynchronizerV2::resetStats() {
+    std::lock_guard<std::mutex> lock(statsMutex_);
+    stats_ = SyncStatsV2();
+    stats_.lastUpdateTime = std::chrono::steady_clock::now();
+    
+    Logger::instance().info("SynchronizerV2 stats reset");
+}
+
+void SynchronizerV2::setSyncEventCallback(SyncEventCallback callback) {
+    syncEventCallback_ = callback;
+}
+
+void SynchronizerV2::setFrameDropCallback(FrameDropCallback callback) {
+    frameDropCallback_ = callback;
+}
+
+void SynchronizerV2::setFrameDuplicateCallback(FrameDuplicateCallback callback) {
+    frameDuplicateCallback_ = callback;
+}
+
+void SynchronizerV2::setSyncErrorCallback(SyncErrorCallback callback) {
+    syncErrorCallback_ = callback;
+}
+
+void SynchronizerV2::enableAdaptiveSync(bool enable) {
+    std::lock_guard<std::mutex> lock(configMutex_);
+    config_.enableAdaptiveSync = enable;
+    
+    Logger::instance().info("Adaptive sync " + std::string(enable ? "enabled" : "disabled"));
+}
+
+void SynchronizerV2::enablePrediction(bool enable) {
+    std::lock_guard<std::mutex> lock(configMutex_);
+    config_.enablePrediction = enable;
+    
+    Logger::instance().info("Prediction " + std::string(enable ? "enabled" : "disabled"));
+}
+
+void SynchronizerV2::setClockUpdateInterval(double interval) {
+    std::lock_guard<std::mutex> lock(configMutex_);
+    config_.clockUpdateInterval = interval;
+    
+    Logger::instance().info("Clock update interval set to: " + std::to_string(interval * 1000) + "ms");
+}
+
+void SynchronizerV2::setSmoothingWindow(int window) {
+    std::lock_guard<std::mutex> lock(configMutex_);
+    config_.smoothingWindow = window;
+    
+    // 调整历史记录大小
+    std::lock_guard<std::mutex> historyLock(historyMutex_);
+    while (audioClockHistory_.size() > static_cast<size_t>(window)) {
+        audioClockHistory_.pop_front();
+    }
+    while (videoClockHistory_.size() > static_cast<size_t>(window)) {
+        videoClockHistory_.pop_front();
+    }
+    while (syncErrorHistory_.size() > static_cast<size_t>(window)) {
+        syncErrorHistory_.pop_front();
+    }
+    
+    Logger::instance().info("Smoothing window set to: " + std::to_string(window));
+}
+
+std::string SynchronizerV2::getDebugInfo() const {
+    std::ostringstream oss;
+    
+    SyncStatsV2 stats = getStats();
+    
+    oss << std::fixed << std::setprecision(3);
+    oss << "SynchronizerV2 Debug Info:\n";
+    oss << "  State: " << static_cast<int>(stats.state) << "\n";
+    oss << "  Master Clock: " << static_cast<int>(stats.masterClockType) << "\n";
+    oss << "  Audio Clock: " << stats.audioClock << "s\n";
+    oss << "  Video Clock: " << stats.videoClock << "s\n";
+    oss << "  External Clock: " << stats.externalClock << "s\n";
+    oss << "  Master Clock: " << stats.masterClock << "s\n";
+    oss << "  Sync Error: " << stats.syncError * 1000 << "ms\n";
+    oss << "  Avg Sync Error: " << stats.avgSyncError * 1000 << "ms\n";
+    oss << "  Max Sync Error: " << stats.maxSyncError * 1000 << "ms\n";
+    oss << "  Total Frames: " << stats.totalFrames << "\n";
+    oss << "  Dropped Frames: " << stats.droppedFrames << "\n";
+    oss << "  Duplicated Frames: " << stats.duplicatedFrames << "\n";
+    oss << "  Running: " << (running_ ? "Yes" : "No") << "\n";
+    oss << "  Paused: " << (paused_ ? "Yes" : "No") << "\n";
+    
+    return oss.str();
+}
+
+void SynchronizerV2::dumpClockInfo() const {
+    std::lock_guard<std::mutex> lock(clockMutex_);
+    
+    Logger::instance().info("Clock Info Dump:");
+    Logger::instance().info("  Audio - PTS: " + std::to_string(audioClock_.pts) + 
+                           ", Speed: " + std::to_string(audioClock_.speed) + 
+                           ", Paused: " + (audioClock_.paused ? "Yes" : "No"));
+    Logger::instance().info("  Video - PTS: " + std::to_string(videoClock_.pts) + 
+                           ", Speed: " + std::to_string(videoClock_.speed) + 
+                           ", Paused: " + (videoClock_.paused ? "Yes" : "No"));
+    Logger::instance().info("  External - PTS: " + std::to_string(externalClock_.pts) + 
+                           ", Speed: " + std::to_string(externalClock_.speed) + 
+                           ", Paused: " + (externalClock_.paused ? "Yes" : "No"));
+}
+
+// 私有方法实现
+
+ErrorCode SynchronizerV2::updateClock(ClockType type, double pts, double time, int serial) {
+    if (!initialized_) {
+        return ErrorCode::NOT_INITIALIZED;
+    }
+    
+    std::lock_guard<std::mutex> lock(clockMutex_);
+    
+    ClockInfo* clock = nullptr;
+    switch (type) {
+        case ClockType::AUDIO:
+            clock = &audioClock_;
+            break;
+        case ClockType::VIDEO:
+            clock = &videoClock_;
+            break;
+        case ClockType::EXTERNAL:
+            clock = &externalClock_;
+            break;
+        default:
+            return ErrorCode::INVALID_PARAMS;
+    }
+    
+    if (time < 0) {
+        time = getCurrentTime();
+    }
+    
+    // 检查序列号
+    if (serial != 0 && clock->serial != serial) {
+        // 序列号不匹配，可能是seek操作，重置时钟
+        resetClock(type);
+        clock->serial = serial;
+    }
+    
+    // 更新时钟
+    clock->pts = pts;
+    clock->time = time;
+    clock->lastUpdate = std::chrono::steady_clock::now();
+    
+    // 平滑处理
+    if (config_.smoothingWindow > 1) {
+        clock->smoothedPts = smoothClock(type, pts);
+    } else {
+        clock->smoothedPts = pts;
+    }
+    
+    // 更新历史记录
+    updateClockHistory(type, pts);
+    
+    // 更新同步状态
+    updateSyncState();
+    
+    // 定期更新统计信息
+    auto now = std::chrono::steady_clock::now();
+    if (std::chrono::duration_cast<std::chrono::milliseconds>(now - lastStatsUpdate_).count() > 100) {
+        updateStats();
+        lastStatsUpdate_ = now;
+    }
+    
+    return ErrorCode::SUCCESS;
+}
+
+double SynchronizerV2::getClock(ClockType type, bool predict) const {
+    std::lock_guard<std::mutex> lock(clockMutex_);
+    
+    const ClockInfo* clock = nullptr;
+    switch (type) {
+        case ClockType::AUDIO:
+            clock = &audioClock_;
+            break;
+        case ClockType::VIDEO:
+            clock = &videoClock_;
+            break;
+        case ClockType::EXTERNAL:
+            clock = &externalClock_;
+            break;
+        case ClockType::SYSTEM:
+            return getCurrentTime();
+        default:
+            return 0.0;
+    }
+    
+    if (clock->paused) {
+        return clock->pts;
+    }
+    
+    // 计算当前时间
+    auto now = std::chrono::steady_clock::now();
+    double elapsed = std::chrono::duration<double>(now - clock->lastUpdate).count();
+    double currentPts = clock->pts + elapsed * clock->speed;
+    
+    // 如果启用预测
+    if (predict && config_.enablePrediction) {
+        return predictClock(type, config_.predictionWindow);
+    }
+    
+    return currentPts;
+}
+
+void SynchronizerV2::resetClock(ClockType type) {
+    ClockInfo* clock = nullptr;
+    switch (type) {
+        case ClockType::AUDIO:
+            clock = &audioClock_;
+            break;
+        case ClockType::VIDEO:
+            clock = &videoClock_;
+            break;
+        case ClockType::EXTERNAL:
+            clock = &externalClock_;
+            break;
+        default:
+            return;
+    }
+    
+    clock->pts = 0.0;
+    clock->time = 0.0;
+    clock->speed = 1.0;
+    clock->serial = 0;
+    clock->paused = false;
+    clock->lastUpdate = std::chrono::steady_clock::now();
+    clock->drift = 0.0;
+    clock->smoothedPts = 0.0;
+}
+
+void SynchronizerV2::pauseClock(ClockType type, bool pause) {
+    ClockInfo* clock = nullptr;
+    switch (type) {
+        case ClockType::AUDIO:
+            clock = &audioClock_;
+            break;
+        case ClockType::VIDEO:
+            clock = &videoClock_;
+            break;
+        case ClockType::EXTERNAL:
+            clock = &externalClock_;
+            break;
+        default:
+            return;
+    }
+    
+    if (clock->paused != pause) {
+        if (pause) {
+            // 暂停时保存当前PTS（直接计算，避免调用getClock导致死锁）
+            if (!clock->paused) {
+                auto now = std::chrono::steady_clock::now();
+                double elapsed = std::chrono::duration<double>(now - clock->lastUpdate).count();
+                clock->pts = clock->pts + elapsed * clock->speed;
+            }
+        }
+        clock->paused = pause;
+        clock->lastUpdate = std::chrono::steady_clock::now();
+    }
+}
+
+void SynchronizerV2::selectMasterClock() {
+    switch (config_.strategy) {
+        case SyncStrategy::AUDIO_MASTER:
+            masterClockType_ = ClockType::AUDIO;
+            break;
+        case SyncStrategy::VIDEO_MASTER:
+            masterClockType_ = ClockType::VIDEO;
+            break;
+        case SyncStrategy::EXTERNAL_MASTER:
+            masterClockType_ = ClockType::EXTERNAL;
+            break;
+        case SyncStrategy::ADAPTIVE:
+            // 自适应选择逻辑
+            if (config_.enableAdaptiveSync) {
+                // 改进的自适应逻辑：优先选择音频，如果没有音频则选择视频
+                // 注意：不依赖pts值，因为在播放开始时pts可能还是0
+                if (hasAudioStream_) {
+                    masterClockType_ = ClockType::AUDIO;
+                } else if (hasVideoStream_) {
+                    masterClockType_ = ClockType::VIDEO;
+                } else {
+                    masterClockType_ = ClockType::EXTERNAL;
+                }
+            } else {
+                masterClockType_ = ClockType::AUDIO; // 默认音频
+            }
+            break;
+    }
+
+    Logger::instance().info("Master clock selected: "
+                            + std::to_string(static_cast<int>(masterClockType_.load()))
+                            + " (hasAudio=" + std::to_string(hasAudioStream_.load())
+                            + ", hasVideo=" + std::to_string(hasVideoStream_.load()) + ")");
+}
+
+void SynchronizerV2::updateSyncState() {
+    if (!running_) {
+        state_ = SyncState::IDLE;
+        return;
+    }
+    
+    if (paused_) {
+        return;
+    }
+    
+    double syncError = calculateSyncErrorInternal();
+    
+    SyncState newState = state_;
+    
+    if (syncError <= config_.syncThreshold) {
+        newState = SyncState::SYNCHRONIZED;
+        recoveryAttempts_ = 0; // 重置恢复尝试次数
+    } else if (syncError <= config_.adaptiveThreshold) {
+        newState = SyncState::DRIFT;
+    } else if (syncError <= config_.maxSyncError) {
+        newState = SyncState::ERROR;
+    } else {
+        newState = SyncState::ERROR;
+        // 尝试恢复
+        if (recoveryAttempts_ < config_.maxRecoveryAttempts) {
+            attemptRecovery();
+            newState = SyncState::RECOVERING;
+        }
+    }
+    
+    if (newState != state_) {
+        SyncState oldState = state_;
+        state_ = newState;
+        notifyStateChange(newState);
+        
+        Logger::instance().info("Sync state changed from " + std::to_string(static_cast<int>(oldState)) + 
+                               " to " + std::to_string(static_cast<int>(newState)));
+    }
+}
+
+void SynchronizerV2::updateStats() {
+    // 统计信息在其他方法中已经更新
+}
+
+double SynchronizerV2::smoothClock(ClockType type, double newPts) {
+    std::lock_guard<std::mutex> lock(historyMutex_);
+    
+    std::deque<double>* history = nullptr;
+    switch (type) {
+        case ClockType::AUDIO:
+            history = &audioClockHistory_;
+            break;
+        case ClockType::VIDEO:
+            history = &videoClockHistory_;
+            break;
+        default:
+            return newPts;
+    }
+    
+    if (history->empty()) {
+        return newPts;
+    }
+    
+    // 简单的指数移动平均
+    double lastSmoothed = history->back();
+    return lastSmoothed * (1.0 - config_.smoothingFactor) + newPts * config_.smoothingFactor;
+}
+
+double SynchronizerV2::predictClock(ClockType type, double futureTime) const {
+    // 注意：此方法假设调用者已经持有clockMutex_锁
+    // 不能再调用getClock，否则会导致死锁
+    
+    const ClockInfo* clock = nullptr;
+    switch (type) {
+        case ClockType::AUDIO:
+            clock = &audioClock_;
+            break;
+        case ClockType::VIDEO:
+            clock = &videoClock_;
+            break;
+        case ClockType::EXTERNAL:
+            clock = &externalClock_;
+            break;
+        default:
+            return 0.0;
+    }
+    
+    if (clock->paused) {
+        return clock->pts;
+    }
+    
+    // 计算当前时间（不调用getClock避免死锁）
+    auto now = std::chrono::steady_clock::now();
+    double elapsed = std::chrono::duration<double>(now - clock->lastUpdate).count();
+    double currentPts = clock->pts + elapsed * clock->speed;
+    
+    return currentPts + futureTime * clock->speed;
+}
+
+void SynchronizerV2::updateClockHistory(ClockType type, double pts) {
+    std::lock_guard<std::mutex> lock(historyMutex_);
+    
+    std::deque<double>* history = nullptr;
+    switch (type) {
+        case ClockType::AUDIO:
+            history = &audioClockHistory_;
+            break;
+        case ClockType::VIDEO:
+            history = &videoClockHistory_;
+            break;
+        default:
+            return;
+    }
+    
+    history->push_back(pts);
+    while (history->size() > static_cast<size_t>(config_.smoothingWindow)) {
+        history->pop_front();
+    }
+}
+
+void SynchronizerV2::attemptRecovery() {
+    recoveryAttempts_++;
+    lastRecoveryTime_ = std::chrono::steady_clock::now();
+    
+    Logger::instance().warning("Attempting sync recovery, attempt: " + std::to_string(recoveryAttempts_));
+    
+    // 重置时钟漂移
+    std::lock_guard<std::mutex> lock(clockMutex_);
+    audioClock_.drift = 0.0;
+    videoClock_.drift = 0.0;
+    externalClock_.drift = 0.0;
+    
+    // 可能需要重新选择主时钟
+    if (config_.enableAdaptiveSync) {
+        selectMasterClock();
+    }
+}
+
+double SynchronizerV2::getCurrentTime() const {
+    auto now = std::chrono::steady_clock::now();
+    return std::chrono::duration<double>(now - startTime_).count();
+}
+
+double SynchronizerV2::getSystemTime() const {
+    return av_gettime_relative() / 1000000.0;
+}
+
+void SynchronizerV2::notifyStateChange(SyncState newState) {
+    if (syncEventCallback_) {
+        syncEventCallback_(state_, newState);
+    }
+}
+
+void SynchronizerV2::notifyFrameDrop(ClockType type, double pts) {
+    if (frameDropCallback_) {
+        frameDropCallback_(type, pts);
+    }
+}
+
+void SynchronizerV2::notifyFrameDuplicate(ClockType type, double pts) {
+    if (frameDuplicateCallback_) {
+        frameDuplicateCallback_(type, pts);
+    }
+}
+
+void SynchronizerV2::notifySyncError(double error, const std::string& reason) {
+    if (syncErrorCallback_) {
+        syncErrorCallback_(error, reason);
+    }
+}
+
+} // namespace utils
+} // namespace av

AV/code/utils/utils_synchronizer_v2.h

@@ -0,0 +1,356 @@
+#ifndef AV_UTILS_SYNCHRONIZER_V2_H
+#define AV_UTILS_SYNCHRONIZER_V2_H
+
+#pragma once
+
+#include "../base/types.h"
+#include "../base/logger.h"
+#include <memory>
+#include <atomic>
+#include <mutex>
+#include <chrono>
+#include <deque>
+#include <functional>
+
+extern "C" {
+#include <libavutil/avutil.h>
+#include <libavutil/time.h>
+}
+
+namespace av {
+namespace utils {
+
+// 同步错误常量
+const ErrorCode SYNC_ERROR = ErrorCode::PROCESSING_ERROR;
+
+/**
+ * 改进的时钟类型
+ */
+enum class ClockType {
+    AUDIO,
+    VIDEO,
+    EXTERNAL,
+    SYSTEM
+};
+
+/**
+ * 同步策略
+ */
+enum class SyncStrategy {
+    AUDIO_MASTER,       // 音频为主时钟
+    VIDEO_MASTER,       // 视频为主时钟
+    EXTERNAL_MASTER,    // 外部时钟为主
+    ADAPTIVE            // 自适应选择
+};
+
+/**
+ * 同步状态
+ */
+enum class SyncState {
+    IDLE,               // 空闲
+    INITIALIZING,       // 初始化中
+    SYNCING,           // 同步中
+    SYNCHRONIZED,      // 已同步
+    DRIFT,             // 轻微漂移
+    ERROR,             // 同步错误
+    RECOVERING         // 恢复中
+};
+
+/**
+ * 时钟信息结构
+ */
+struct ClockInfo {
+    double pts = 0.0;                                           // 当前PTS
+    double time = 0.0;                                          // 系统时间
+    double speed = 1.0;                                         // 播放速度
+    int serial = 0;                                             // 序列号
+    bool paused = false;                                        // 是否暂停
+    std::chrono::steady_clock::time_point lastUpdate;          // 最后更新时间
+    double drift = 0.0;                                         // 时钟漂移
+    double smoothedPts = 0.0;                                   // 平滑后的PTS
+    
+    ClockInfo() {
+        lastUpdate = std::chrono::steady_clock::now();
+    }
+};
+
+/**
+ * 同步配置
+ */
+struct SyncConfigV2 {
+    SyncStrategy syncStrategy = SyncStrategy::ADAPTIVE;  // 同步策略
+    
+    // 同步阈值
+    double syncThreshold = 0.04;           // 40ms - 基本同步阈值
+    double audioSyncThreshold = 0.04;      // 40ms - 音频同步阈值
+    double videoSyncThreshold = 0.04;      // 40ms - 视频同步阈值
+    double maxSyncError = 0.1;             // 100ms - 最大允许误差
+    double frameDropThreshold = 0.05;      // 50ms - 丢帧阈值
+    double frameDupThreshold = 0.1;        // 100ms - 重复帧阈值
+    
+    // 帧控制
+    bool enableFrameDrop = true;           // 启用丢帧
+    bool enableFrameDuplicate = true;      // 启用重复帧
+    
+    // 时钟更新参数
+    double clockUpdateInterval = 0.01;     // 10ms - 时钟更新间隔
+    int smoothingWindow = 10;              // 平滑窗口大小
+    double smoothingFactor = 0.1;          // 平滑因子
+    
+    // 自适应参数
+    bool enableAdaptiveSync = true;
+    double adaptiveThreshold = 0.02;       // 20ms - 自适应阈值
+    int adaptiveWindow = 30;               // 自适应窗口
+    
+    // 恢复参数
+    double recoveryThreshold = 0.2;        // 200ms - 恢复阈值
+    int maxRecoveryAttempts = 5;           // 最大恢复尝试次数
+    bool enableErrorRecovery = true;       // 启用错误恢复
+    
+    // 性能参数
+    bool enablePrediction = true;          // 启用预测
+    double predictionWindow = 0.1;         // 100ms - 预测窗口
+    
+    // 兼容性字段 (保持向后兼容)
+    SyncStrategy strategy = SyncStrategy::ADAPTIVE;  // 与syncStrategy相同
+};
+
+/**
+ * 同步统计信息
+ */
+struct SyncStatsV2 {
+    // 时钟值
+    double audioClock = 0.0;
+    double videoClock = 0.0;
+    double externalClock = 0.0;
+    double masterClock = 0.0;
+    
+    // 延迟信息
+    double audioDelay = 0.0;
+    double videoDelay = 0.0;
+    double syncError = 0.0;
+    double avgSyncError = 0.0;
+    double maxSyncError = 0.0;
+    
+    // 帧处理统计
+    uint64_t totalFrames = 0;
+    uint64_t droppedFrames = 0;
+    uint64_t duplicatedFrames = 0;
+    uint64_t syncAdjustments = 0;
+    
+    // 状态信息
+    SyncState state = SyncState::IDLE;
+    ClockType masterClockType = ClockType::AUDIO;
+    std::chrono::steady_clock::time_point lastUpdateTime;
+    
+    // 性能指标
+    double cpuUsage = 0.0;
+    double memoryUsage = 0.0;
+};
+
+/**
+ * 帧决策结果
+ */
+enum class FrameAction {
+    DISPLAY,         // 正常显示
+    DROP,            // 丢弃帧
+    Frame_DUPLICATE, // 重复帧
+    DELAY            // 延迟显示
+};
+
+/**
+ * 帧决策信息
+ */
+struct FrameDecision {
+    FrameAction action = FrameAction::DISPLAY;
+    double delay = 0.0;                     // 延迟时间
+    double targetPts = 0.0;                 // 目标PTS
+    double actualPts = 0.0;                 // 实际PTS
+    double syncError = 0.0;                 // 同步误差
+    std::string reason;                     // 决策原因
+};
+
+/**
+ * 回调函数类型
+ */
+using SyncEventCallback = std::function<void(SyncState oldState, SyncState newState)>;
+using FrameDropCallback = std::function<void(ClockType clockType, double pts)>;
+using FrameDuplicateCallback = std::function<void(ClockType clockType, double pts)>;
+using SyncErrorCallback = std::function<void(double error, const std::string& reason)>;
+
+/**
+ * 改进的同步器类 - 基于AVPlayer2的经验重新设计
+ * 
+ * 主要改进:
+ * 1. 更精确的时钟管理和同步算法
+ * 2. 自适应同步策略
+ * 3. 更好的错误恢复机制
+ * 4. 性能优化和预测算法
+ * 5. 详细的统计和监控
+ */
+class SynchronizerV2 {
+public:
+    explicit SynchronizerV2(const SyncConfigV2& config = SyncConfigV2());
+    ~SynchronizerV2();
+    
+    // 生命周期管理
+    ErrorCode initialize();
+    ErrorCode start();
+    ErrorCode stop();
+    ErrorCode pause();
+    ErrorCode resume();
+    ErrorCode reset();
+    
+    // 设置流信息
+    void setStreamInfo(bool hasAudio, bool hasVideo);
+    ErrorCode close();
+    
+    // 时钟设置 - 改进的接口
+    ErrorCode setAudioClock(double pts, double time = -1, int serial = 0);
+    ErrorCode setVideoClock(double pts, double time = -1, int serial = 0);
+    ErrorCode setExternalClock(double time = -1, int serial = 0);
+    
+    // 时钟获取 - 支持预测
+    double getAudioClock(bool predict = false) const;
+    double getVideoClock(bool predict = false) const;
+    double getExternalClock(bool predict = false) const;
+    double getMasterClock(bool predict = false) const;
+    ClockType getMasterClockType() const { return masterClockType_; }
+    
+    // 同步决策 - 核心功能
+    FrameDecision shouldDisplayVideoFrame(double pts, double duration = 0.0);
+    FrameDecision shouldPlayAudioFrame(double pts, double duration = 0.0);
+    double calculateTargetDelay(double pts, ClockType clockType);
+    
+    // 同步控制
+    bool shouldDropFrame(double pts, ClockType clockType);
+    bool shouldDuplicateFrame(double pts, ClockType clockType);
+    double calculateSyncError() const;
+    double calculateAudioDelay(double pts) const;
+    double calculateVideoDelay(double pts) const;
+    
+    // 配置管理
+    void setConfig(const SyncConfigV2& config);
+    SyncConfigV2 getConfig() const;
+    void setSyncStrategy(SyncStrategy strategy);
+    SyncStrategy getSyncStrategy() const;
+    void setPlaybackSpeed(double speed);
+    double getPlaybackSpeed() const;
+    
+    // 状态查询
+    SyncState getState() const { return state_; }
+    bool isSynchronized() const;
+    bool isRunning() const { return running_; }
+    bool isPaused() const { return paused_; }
+    
+    // 统计信息
+    SyncStatsV2 getStats() const;
+    void resetStats();
+    
+    // 回调设置
+    void setSyncEventCallback(SyncEventCallback callback);
+    void setFrameDropCallback(FrameDropCallback callback);
+    void setFrameDuplicateCallback(FrameDuplicateCallback callback);
+    void setSyncErrorCallback(SyncErrorCallback callback);
+    
+    // 高级功能
+    void enableAdaptiveSync(bool enable);
+    void enablePrediction(bool enable);
+    void setClockUpdateInterval(double interval);
+    void setSmoothingWindow(int window);
+    
+    // 调试和监控
+    std::string getDebugInfo() const;
+    void dumpClockInfo() const;
+
+private:
+    // 内部时钟管理
+    ErrorCode updateClock(ClockType type, double pts, double time, int serial);
+    double getClock(ClockType type, bool predict = false) const;
+    void resetClock(ClockType type);
+    void pauseClock(ClockType type, bool pause);
+    
+    // 同步算法
+    void updateMasterClock();
+    void selectMasterClock();
+    void updateSyncState();
+    void updateStats();
+    
+    // 平滑和预测
+    double smoothClock(ClockType type, double newPts);
+    double predictClock(ClockType type, double futureTime) const;
+    void updateClockHistory(ClockType type, double pts);
+    
+    // 自适应算法
+    void adaptiveSyncUpdate();
+    bool shouldSwitchMasterClock();
+    void handleSyncError(double error);
+    
+    // 错误恢复
+    void attemptRecovery();
+    void resetSyncState();
+    
+    // 工具函数
+    double getCurrentTime() const;
+    double getSystemTime() const;
+    void notifyStateChange(SyncState newState);
+    void notifyFrameDrop(ClockType type, double pts);
+    void notifyFrameDuplicate(ClockType type, double pts);
+    void notifySyncError(double error, const std::string& reason);
+    
+    // 内部版本，假设调用者已经持有clockMutex_锁
+    double calculateSyncErrorInternal() const;
+    
+private:
+    // 配置
+    SyncConfigV2 config_;
+    mutable std::mutex configMutex_;
+    
+    // 状态
+    std::atomic<SyncState> state_{SyncState::IDLE};
+    std::atomic<ClockType> masterClockType_{ClockType::AUDIO};
+    std::atomic<bool> initialized_{false};
+    std::atomic<bool> running_{false};
+    std::atomic<bool> paused_{false};
+    
+    // 时钟
+    ClockInfo audioClock_;
+    ClockInfo videoClock_;
+    ClockInfo externalClock_;
+    mutable std::mutex clockMutex_;
+    
+    // 历史记录
+    std::deque<double> audioClockHistory_;
+    std::deque<double> videoClockHistory_;
+    std::deque<double> syncErrorHistory_;
+    mutable std::mutex historyMutex_;
+    
+    // 统计信息
+    SyncStatsV2 stats_;
+    mutable std::mutex statsMutex_;
+    
+    // 时间记录
+    std::chrono::steady_clock::time_point startTime_;
+    std::chrono::steady_clock::time_point lastClockUpdate_;
+    std::chrono::steady_clock::time_point lastStatsUpdate_;
+
+    // 自适应参数
+    int recoveryAttempts_ = 0;
+    double lastSyncError_ = 0.0;
+    std::chrono::steady_clock::time_point lastRecoveryTime_;
+    
+    // 回调函数
+    SyncEventCallback syncEventCallback_;
+    FrameDropCallback frameDropCallback_;
+    FrameDuplicateCallback frameDuplicateCallback_;
+    SyncErrorCallback syncErrorCallback_;
+    
+    // 流信息
+    std::atomic<bool> hasAudioStream_{false};
+    std::atomic<bool> hasVideoStream_{false};
+};
+
+} // namespace utils
+} // namespace av
+
+#endif // AV_UTILS_SYNCHRONIZER_V2_H

AV/test_audio.cpp

@@ -0,0 +1,189 @@
+#include <chrono>
+#include <iostream>
+#include <string>
+#include <thread>
+
+#include "code/base/logger.h"
+#include "code/player/player_core_v2.h"
+
+using namespace av::player;
+using namespace av::utils;
+
+// 简单的事件回调类
+class TestPlayerCallback : public PlayerEventCallback {
+public:
+    void onStateChanged(PlayerState newState) override {
+        std::string stateStr;
+        switch (newState) {
+            case PlayerState::Idle: stateStr = "Idle"; break;
+            case PlayerState::Opening: stateStr = "Opening"; break;
+            case PlayerState::Stopped: stateStr = "Stopped"; break;
+            case PlayerState::Playing: stateStr = "Playing"; break;
+            case PlayerState::Paused: stateStr = "Paused"; break;
+            case PlayerState::Seeking: stateStr = "Seeking"; break;
+            case PlayerState::Error: stateStr = "Error"; break;
+        }
+        std::cout << "[EVENT] State changed to: " << stateStr << std::endl;
+    }
+    
+    void onPositionChanged(int64_t position) override {
+        static auto lastUpdate = std::chrono::steady_clock::now();
+        auto now = std::chrono::steady_clock::now();
+        if (std::chrono::duration_cast<std::chrono::seconds>(now - lastUpdate).count() >= 1) {
+            double seconds = position / 1000000.0;
+            std::cout << "[EVENT] Position: " << std::fixed << std::setprecision(2) << seconds << "s" << std::endl;
+            lastUpdate = now;
+        }
+    }
+    
+    void onMediaInfoChanged(const MediaInfo& info) override {
+        std::cout << "[EVENT] Media info changed:" << std::endl;
+        std::cout << "  File: " << info.filename << std::endl;
+        std::cout << "  Duration: " << (info.duration / 1000000.0) << "s" << std::endl;
+        std::cout << "  Has Video: " << (info.hasVideo ? "Yes" : "No") << std::endl;
+        std::cout << "  Has Audio: " << (info.hasAudio ? "Yes" : "No") << std::endl;
+        
+        if (info.hasAudio) {
+            std::cout << "  Audio: " << info.sampleRate << " Hz, " << info.channels << " channels" << std::endl;
+        }
+    }
+    
+    void onErrorOccurred(const std::string& error) override {
+        std::cout << "[ERROR] " << error << std::endl;
+    }
+    
+    void onFrameDropped(int64_t totalDropped) override {
+        std::cout << "[WARNING] Frame dropped, total: " << totalDropped << std::endl;
+    }
+    
+    void onSyncError(double error, const std::string& reason) override {
+        std::cout << "[WARNING] Sync error: " << (error * 1000) << "ms, reason: " << reason << std::endl;
+    }
+
+    void onEndOfFile() override {}
+};
+
+int main() {
+    // 初始化日志系统
+    Logger::instance().setLevel(LogLevel::DEBUG);
+    Logger::instance().info("Audio Test Started");
+    
+    try {
+        // 创建同步配置
+        SyncConfigV2 syncConfig;
+        syncConfig.syncStrategy = SyncStrategy::ADAPTIVE;
+        syncConfig.audioSyncThreshold = 0.040;
+        syncConfig.videoSyncThreshold = 0.020;
+        syncConfig.maxSyncError = 0.200;
+        syncConfig.clockUpdateInterval = 10;
+        syncConfig.smoothingWindow = 10;
+        syncConfig.enableAdaptiveSync = true;
+        syncConfig.enableFrameDrop = true;
+        syncConfig.enableFrameDuplicate = true;
+        syncConfig.enablePrediction = true;
+        syncConfig.enableErrorRecovery = true;
+        
+        // 创建播放器实例
+        auto player = std::make_unique<PlayerCoreV2>(syncConfig);
+        
+        // 创建事件回调
+        auto callback = std::make_unique<TestPlayerCallback>();
+        player->setEventCallback(callback.get());
+        
+        // 测试音频文件路径（请根据实际情况修改）
+        std::string audioFile = "C:\\Windows\\Media\\notify.wav"; // Windows系统音频文件
+        
+        std::cout << "Testing with audio file: " << audioFile << std::endl;
+        
+        // 打开音频文件
+        auto result = player->openFile(audioFile);
+        if (result != ErrorCode::SUCCESS) {
+            std::cout << "Failed to open audio file: " << static_cast<int>(result) << std::endl;
+            
+            // 尝试其他常见的音频文件
+            audioFile = "C:\\Windows\\Media\\chimes.wav";
+            std::cout << "Trying alternative file: " << audioFile << std::endl;
+            result = player->openFile(audioFile);
+            
+            if (result != ErrorCode::SUCCESS) {
+                std::cout << "Failed to open alternative audio file: " << static_cast<int>(result) << std::endl;
+                std::cout << "Please provide a valid audio file path." << std::endl;
+                return 1;
+            }
+        }
+        
+        std::cout << "Audio file opened successfully!" << std::endl;
+        
+        // 获取媒体信息
+        auto mediaInfo = player->getMediaInfo();
+        std::cout << "Media duration: " << (mediaInfo.duration / 1000000.0) << " seconds" << std::endl;
+        std::cout << "Has audio: " << (mediaInfo.hasAudio ? "Yes" : "No") << std::endl;
+        
+        if (!mediaInfo.hasAudio) {
+            std::cout << "No audio stream found in the file!" << std::endl;
+            return 1;
+        }
+        
+        // 设置音量为最大
+        player->setVolume(1.0);
+        std::cout << "Volume set to: " << player->getVolume() << std::endl;
+        
+        // 开始播放
+        result = player->play();
+        if (result != ErrorCode::SUCCESS) {
+            std::cout << "Failed to start playback: " << static_cast<int>(result) << std::endl;
+            return 1;
+        }
+        
+        std::cout << "Playback started! You should hear audio now." << std::endl;
+        std::cout << "Current volume: " << player->getVolume() << std::endl;
+        
+        // 等待播放完成
+        double totalDuration = mediaInfo.duration / 1000000.0;
+        std::cout << "Waiting for playback to complete (" << totalDuration << " seconds)..." << std::endl;
+        
+        // 监控播放状态
+        auto startTime = std::chrono::steady_clock::now();
+        while (true) {
+            auto currentTime = std::chrono::steady_clock::now();
+            auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(currentTime - startTime).count();
+            
+            auto state = player->getState();
+            auto currentPos = player->getCurrentTime() / 1000000.0;
+            
+            std::cout << "State: " << static_cast<int>(state) << ", Position: " << currentPos << "s" << std::endl;
+            
+            // 如果播放完成或出错，退出
+            if (state == PlayerState::Stopped || state == PlayerState::Error) {
+                break;
+            }
+            
+            // 如果播放时间接近总时长，停止播放
+            if (currentPos >= totalDuration - 0.1) {
+                std::cout << "Playback completed, stopping..." << std::endl;
+                player->stop();
+                break;
+            }
+            
+            // 超时保护
+            if (elapsed > totalDuration + 5) {
+                std::cout << "Timeout, stopping playback..." << std::endl;
+                player->stop();
+                break;
+            }
+            
+            std::this_thread::sleep_for(std::chrono::milliseconds(500));
+        }
+        
+        std::cout << "Audio test completed." << std::endl;
+        
+    } catch (const std::exception& e) {
+        std::cerr << "Exception: " << e.what() << std::endl;
+        return 1;
+    } catch (...) {
+        std::cerr << "Unknown exception occurred" << std::endl;
+        return 1;
+    }
+    
+    return 0;
+}

AV/test_audio_debug.cpp

@@ -0,0 +1,336 @@
+#include <chrono>
+#include <string>
+#include <thread>
+#include <iomanip>
+
+#include "code/base/logger.h"
+#include "code/player/player_core_v2.h"
+
+#include <QApplication>
+#include <QAudioDeviceInfo>
+#include <QAudioOutput>
+#include <QAudioFormat>
+#include <QDebug>
+
+using namespace av::player;
+using namespace av::utils;
+
+// 增强的事件回调类，包含更详细的调试信息
+class DebugPlayerCallback : public PlayerEventCallback {
+public:
+    void onStateChanged(PlayerState newState) override {
+        std::string stateStr;
+        switch (newState) {
+            case PlayerState::Idle: stateStr = "Idle"; break;
+            case PlayerState::Opening: stateStr = "Opening"; break;
+            case PlayerState::Stopped: stateStr = "Stopped"; break;
+            case PlayerState::Playing: stateStr = "Playing"; break;
+            case PlayerState::Paused: stateStr = "Paused"; break;
+            case PlayerState::Seeking: stateStr = "Seeking"; break;
+            case PlayerState::Error: stateStr = "Error"; break;
+        }
+        Logger::instance().info("[EVENT] State changed to: " + stateStr);
+    }
+    
+    void onPositionChanged(int64_t position) override {
+        static auto lastUpdate = std::chrono::steady_clock::now();
+        auto now = std::chrono::steady_clock::now();
+        if (std::chrono::duration_cast<std::chrono::seconds>(now - lastUpdate).count() >= 1) {
+            double seconds = position / 1000000.0;
+            Logger::instance().debug("[EVENT] Position: " + std::to_string(seconds) + "s");
+            lastUpdate = now;
+        }
+    }
+    
+    void onMediaInfoChanged(const MediaInfo& info) override {
+        Logger::instance().info("[EVENT] Media info changed:");
+        Logger::instance().info("  File: " + info.filename);
+        Logger::instance().info("  Duration: " + std::to_string(info.duration / 1000000.0) + "s");
+        Logger::instance().info("  Has Video: " + std::string(info.hasVideo ? "Yes" : "No"));
+        Logger::instance().info("  Has Audio: " + std::string(info.hasAudio ? "Yes" : "No"));
+        
+        if (info.hasAudio) {
+            Logger::instance().info("  Audio: " + std::to_string(info.sampleRate) + " Hz, " + std::to_string(info.channels) + " channels");
+        }
+    }
+    
+    void onErrorOccurred(const std::string& error) override {
+        Logger::instance().error("[ERROR] " + error);
+    }
+    
+    void onFrameDropped(int64_t totalDropped) override {
+        Logger::instance().warningf("[WARNING] Frame dropped, total: "
+                                    + std::to_string(totalDropped));
+    }
+    
+    void onSyncError(double error, const std::string& reason) override {
+        Logger::instance().warningf("[WARNING] Sync error: " + std::to_string(error * 1000)
+                                    + "ms, reason: " + reason);
+    }
+
+    void onEndOfFile() override {
+        Logger::instance().info("[EVENT] End of file reached");
+    }
+};
+
+// 检查系统音频设备
+void checkAudioDevices() {
+    Logger::instance().info("\n=== 音频设备检查 ===");
+    
+    // 获取默认输出设备
+    QAudioDeviceInfo defaultDevice = QAudioDeviceInfo::defaultOutputDevice();
+    Logger::instance().info("默认音频输出设备: " + defaultDevice.deviceName().toStdString());
+    
+    // 列出所有可用的音频输出设备
+    QList<QAudioDeviceInfo> devices = QAudioDeviceInfo::availableDevices(QAudio::AudioOutput);
+    Logger::instance().info("可用音频输出设备数量: " + std::to_string(devices.size()));
+    
+    for (int i = 0; i < devices.size(); ++i) {
+        const QAudioDeviceInfo& device = devices[i];
+        Logger::instance().info("  设备 " + std::to_string(i + 1) + ": " + device.deviceName().toStdString());
+        
+        // 检查支持的采样率
+        QList<int> sampleRates = device.supportedSampleRates();
+        std::string ratesStr = "    支持的采样率: ";
+        for (int rate : sampleRates) {
+            ratesStr += std::to_string(rate) + " ";
+        }
+        Logger::instance().info(ratesStr);
+        
+        // 检查支持的通道数
+        QList<int> channels = device.supportedChannelCounts();
+        std::string channelsStr = "    支持的通道数: ";
+        for (int ch : channels) {
+            channelsStr += std::to_string(ch) + " ";
+        }
+        Logger::instance().info(channelsStr);
+    }
+}
+
+// 测试Qt音频输出
+void testQtAudioOutput() {
+    Logger::instance().info("\n=== Qt音频输出测试 ===");
+    
+    // 设置音频格式
+    QAudioFormat format;
+    format.setSampleRate(44100);
+    format.setChannelCount(2);
+    format.setSampleSize(16);
+    format.setCodec("audio/pcm");
+    format.setByteOrder(QAudioFormat::LittleEndian);
+    format.setSampleType(QAudioFormat::SignedInt);
+    
+    // 检查默认设备是否支持该格式
+    QAudioDeviceInfo deviceInfo = QAudioDeviceInfo::defaultOutputDevice();
+    if (!deviceInfo.isFormatSupported(format)) {
+        Logger::instance().warningf("警告: 默认设备不支持指定的音频格式");
+        format = deviceInfo.nearestFormat(format);
+        Logger::instance().info("使用最接近的格式: " + std::to_string(format.sampleRate()) + "Hz, " 
+                  + std::to_string(format.channelCount()) + "ch, " + std::to_string(format.sampleSize()) + "bit");
+    } else {
+        Logger::instance().info("默认设备支持指定的音频格式");
+    }
+    
+    // 创建音频输出
+    QAudioOutput* audioOutput = new QAudioOutput(format);
+    if (!audioOutput) {
+        Logger::instance().error("错误: 无法创建QAudioOutput");
+        return;
+    }
+    
+    Logger::instance().info("QAudioOutput创建成功");
+    Logger::instance().info("缓冲区大小: " + std::to_string(audioOutput->bufferSize()) + " bytes");
+    Logger::instance().info("音量: " + std::to_string(audioOutput->volume()));
+    
+    // 尝试启动音频设备
+    QIODevice* device = audioOutput->start();
+    if (!device) {
+        Logger::instance().error("错误: 无法启动音频设备");
+        delete audioOutput;
+        return;
+    }
+    
+    Logger::instance().info("音频设备启动成功");
+    
+    // 生成并播放测试音调（440Hz正弦波）
+    const int sampleRate = format.sampleRate();
+    const int channels = format.channelCount();
+    const double frequency = 440.0; // A4音符
+    const double duration = 2.0; // 2秒
+    const int totalSamples = static_cast<int>(sampleRate * duration);
+    
+    QByteArray testData;
+    testData.resize(totalSamples * channels * sizeof(int16_t));
+    int16_t* samples = reinterpret_cast<int16_t*>(testData.data());
+    
+    for (int i = 0; i < totalSamples; ++i) {
+        double time = static_cast<double>(i) / sampleRate;
+        int16_t sample = static_cast<int16_t>(16383 * std::sin(2.0 * M_PI * frequency * time));
+        
+        for (int ch = 0; ch < channels; ++ch) {
+            samples[i * channels + ch] = sample;
+        }
+    }
+    
+    Logger::instance().info("播放测试音调 (440Hz, 2秒)...");
+    
+    // 分块写入音频数据
+    const int chunkSize = 4096;
+    int bytesWritten = 0;
+    
+    while (bytesWritten < testData.size()) {
+        int remainingBytes = testData.size() - bytesWritten;
+        int writeSize = std::min(chunkSize, remainingBytes);
+        
+        qint64 written = device->write(testData.data() + bytesWritten, writeSize);
+        if (written > 0) {
+            bytesWritten += written;
+        }
+        
+        // 等待一小段时间
+        std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    }
+    
+    Logger::instance().info("测试音调播放完成");
+    
+    // 等待播放完成
+    std::this_thread::sleep_for(std::chrono::milliseconds(500));
+    
+    audioOutput->stop();
+    delete audioOutput;
+}
+
+int main(int argc, char* argv[]) {
+    // 创建QApplication实例（Qt音频需要）
+    QApplication app(argc, argv);
+    Logger::instance().initialize("test.log", LogLevel::DEBUG, false, true);
+    // 初始化日志系统
+    Logger::instance().setLevel(LogLevel::DEBUG);
+    Logger::instance().info("Enhanced Audio Debug Test Started");
+
+    try {
+        // 检查音频设备
+        checkAudioDevices();
+        
+        // 测试Qt音频输出
+        // testQtAudioOutput();
+
+        Logger::instance().info("\n=== PlayerCoreV2音频测试 ===");
+        
+        // 创建同步配置
+        SyncConfigV2 syncConfig;
+        syncConfig.syncStrategy = SyncStrategy::ADAPTIVE;
+        syncConfig.audioSyncThreshold = 0.040;
+        syncConfig.videoSyncThreshold = 0.020;
+        syncConfig.maxSyncError = 0.200;
+        syncConfig.clockUpdateInterval = 10;
+        syncConfig.smoothingWindow = 10;
+        syncConfig.enableAdaptiveSync = true;
+        syncConfig.enableFrameDrop = true;
+        syncConfig.enableFrameDuplicate = true;
+        syncConfig.enablePrediction = true;
+        syncConfig.enableErrorRecovery = true;
+        
+        // 创建播放器实例
+        auto player = std::make_unique<PlayerCoreV2>(syncConfig);
+        
+        // 创建事件回调
+        auto callback = std::make_unique<DebugPlayerCallback>();
+        player->setEventCallback(callback.get());
+        
+        // 测试音频文件路径
+        std::string audioFile = "C:\\Windows\\Media\\notify.wav";
+        
+        Logger::instance().info("测试音频文件: " + audioFile);
+        
+        // 打开音频文件
+        auto result = player->openFile(audioFile);
+        if (result != ErrorCode::SUCCESS) {
+            Logger::instance().error("无法打开音频文件: " + std::to_string(static_cast<int>(result)));
+            
+            // 尝试其他文件
+            audioFile = "C:\\Windows\\Media\\chimes.wav";
+            Logger::instance().info("尝试备用文件: " + audioFile);
+            result = player->openFile(audioFile);
+            
+            if (result != ErrorCode::SUCCESS) {
+                Logger::instance().error("无法打开备用音频文件: " + std::to_string(static_cast<int>(result)));
+                return 1;
+            }
+        }
+        
+        Logger::instance().info("音频文件打开成功!");
+        
+        // 获取媒体信息
+        auto mediaInfo = player->getMediaInfo();
+        Logger::instance().info("媒体时长: " + std::to_string(mediaInfo.duration / 1000000.0) + " 秒");
+        Logger::instance().info("包含音频: " + std::string(mediaInfo.hasAudio ? "是" : "否"));
+        
+        if (!mediaInfo.hasAudio) {
+            Logger::instance().error("文件中未找到音频流!");
+            return 1;
+        }
+        
+        // 设置音量为最大
+        player->setVolume(1.0);
+        Logger::instance().info("音量设置为: " + std::to_string(player->getVolume()));
+        
+        // 开始播放
+        result = player->play();
+        if (result != ErrorCode::SUCCESS) {
+            Logger::instance().error("播放启动失败: " + std::to_string(static_cast<int>(result)));
+            return 1;
+        }
+        
+        Logger::instance().info("播放已开始! 现在应该能听到声音了.");
+        Logger::instance().info("当前音量: " + std::to_string(player->getVolume()));
+        
+        // 等待播放完成
+        double totalDuration = mediaInfo.duration / 1000000.0;
+        Logger::instance().info("等待播放完成 (" + std::to_string(totalDuration) + " 秒)...");
+        
+        // 监控播放状态
+        auto startTime = std::chrono::steady_clock::now();
+        while (true) {
+            auto currentTime = std::chrono::steady_clock::now();
+            auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(currentTime - startTime).count();
+            
+            auto state = player->getState();
+            auto currentPos = player->getCurrentTime() / 1000000.0;
+            
+            Logger::instance().debug("状态: " + std::to_string(static_cast<int>(state)) + ", 位置: " + std::to_string(currentPos) + "s");
+            
+            // 如果播放完成或出错，退出
+            if (state == PlayerState::Stopped || state == PlayerState::Error) {
+                break;
+            }
+            
+            // 如果播放时间接近总时长，停止播放
+            if (currentPos >= totalDuration - 0.1) {
+                Logger::instance().info("播放完成，正在停止...");
+                player->stop();
+                break;
+            }
+            
+            // 超时保护
+            if (elapsed > totalDuration + 5) {
+                Logger::instance().warningf("超时，停止播放...");
+                player->stop();
+                break;
+            }
+            
+            std::this_thread::sleep_for(std::chrono::milliseconds(500));
+        }
+        
+        Logger::instance().info("音频测试完成.");
+
+    } catch (const std::exception& e) {
+        Logger::instance().error("异常: " + std::string(e.what()));
+        return 1;
+    } catch (...) {
+        Logger::instance().error("发生未知异常");
+        return 1;
+    }
+
+    return 0;
+}

AV/test_playerv2.pri

@@ -0,0 +1,22 @@
+# PlayerV2 Test Configuration
+# Include this file in your main .pro file to enable PlayerV2 testing
+
+# Uncomment the line below to enable PlayerV2 example
+SOURCES += $$PWD/code/examples/player_v2_example.cpp
+
+# Required Qt modules for PlayerV2
+QT += core widgets opengl multimedia
+
+# Compiler flags for PlayerV2
+CONFIG += c++17
+
+# Define for PlayerV2 features
+DEFINES += PLAYERV2_ENABLED
+
+# Additional include paths if needed
+# INCLUDEPATH += $$PWD/code/base
+# INCLUDEPATH += $$PWD/code/utils
+# INCLUDEPATH += $$PWD/code/player
+
+# FFmpeg libraries (adjust paths as needed)
+# LIBS += -lavformat -lavcodec -lavutil -lswscale -lswresample