video-pc/AV/code/utils/utils_synchronizer.h

#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