AAA

AvPlayer2/interfaces/IAudioRenderer.h

@@ -0,0 +1,173 @@
+#ifndef IAUDIORENDERER_H
+#define IAUDIORENDERER_H
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+namespace AVPlayer2 {
+namespace Core {
+
+/**
+ * 音频渲染器状态枚举
+ */
+enum class AudioRendererState {
+    Stopped,    // 停止状态
+    Playing,    // 播放状态
+    Paused,     // 暂停状态
+    Error       // 错误状态
+};
+
+} // namespace Core
+
+namespace Types {
+
+/**
+ * 音频格式参数
+ */
+struct AudioFormat {
+    int sampleRate;     // 采样率
+    int channels;       // 声道数
+    int bitsPerSample;  // 位深度
+    int frameSize;      // 帧大小
+};
+
+} // namespace Types
+
+namespace Core {
+
+/**
+ * 音频渲染器抽象接口
+ * 提供与平台无关的音频输出功能
+ */
+class IAudioRenderer {
+public:
+    virtual ~IAudioRenderer() = default;
+
+    /**
+     * 初始化音频渲染器
+     * @param format 音频格式参数
+     * @return 是否初始化成功
+     */
+    virtual bool initialize(const Types::AudioFormat& format) = 0;
+
+    /**
+     * 开始播放
+     * @return 是否开始成功
+     */
+    virtual bool start() = 0;
+
+    /**
+     * 停止播放
+     */
+    virtual void stop() = 0;
+
+    /**
+     * 暂停播放
+     */
+    virtual void pause() = 0;
+
+    /**
+     * 恢复播放
+     */
+    virtual void resume() = 0;
+
+    /**
+     * 写入音频数据
+     * @param data 音频数据指针
+     * @param size 数据大小（字节）
+     * @return 实际写入的字节数
+     */
+    virtual int writeData(const char* data, int size) = 0;
+
+    /**
+     * 设置音量
+     * @param volume 音量值 (0.0 - 1.0)
+     */
+    virtual void setVolume(float volume) = 0;
+
+    /**
+     * 获取当前音量
+     * @return 当前音量值 (0.0 - 1.0)
+     */
+    virtual float getVolume() const = 0;
+
+    /**
+     * 设置静音状态
+     * @param muted 是否静音
+     */
+    virtual void setMuted(bool muted) = 0;
+
+    /**
+     * 获取静音状态
+     * @return 是否静音
+     */
+    virtual bool isMuted() const = 0;
+
+    /**
+     * 获取当前状态
+     * @return 渲染器状态
+     */
+    virtual AudioRendererState getState() const = 0;
+
+    /**
+     * 获取缓冲区大小
+     * @return 缓冲区大小（字节）
+     */
+    virtual int getBufferSize() const = 0;
+
+    /**
+     * 获取可用缓冲区大小
+     * @return 可用缓冲区大小（字节）
+     */
+    virtual int getAvailableBufferSize() const = 0;
+
+    /**
+     * 清空缓冲区
+     */
+    virtual void clearBuffer() = 0;
+
+    /**
+     * 设置状态变化回调
+     * @param callback 状态变化回调函数
+     */
+    virtual void setStateCallback(std::function<void(AudioRendererState)> callback) = 0;
+
+    /**
+     * 设置缓冲区不足回调
+     * @param callback 缓冲区不足回调函数
+     */
+    virtual void setUnderrunCallback(std::function<void()> callback) = 0;
+};
+
+/**
+ * 音频渲染器工厂接口
+ */
+class IAudioRendererFactory {
+public:
+    virtual ~IAudioRendererFactory() = default;
+
+    /**
+     * 创建音频渲染器实例
+     * @return 音频渲染器智能指针
+     */
+    virtual std::unique_ptr<IAudioRenderer> createRenderer() = 0;
+
+    /**
+     * 获取支持的音频格式列表
+     * @return 支持的音频格式列表
+     */
+    virtual std::vector<Types::AudioFormat> getSupportedFormats() = 0;
+
+    /**
+     * 检查是否支持指定格式
+     * @param format 音频格式
+     * @return 是否支持
+     */
+    virtual bool isFormatSupported(const Types::AudioFormat& format) = 0;
+};
+
+} // namespace Core
+} // namespace AVPlayer2
+
+#endif // IAUDIORENDERER_H

AvPlayer2/interfaces/IBufferManager.h

@@ -0,0 +1,475 @@
+#ifndef IBUFFERMANAGER_H
+#define IBUFFERMANAGER_H
+
+#include <memory>
+#include <functional>
+#include <chrono>
+#include <string>
+#include <vector>
+
+namespace AVPlayer2 {
+namespace Core {
+
+/**
+ * 缓冲区状态枚举
+ */
+enum class BufferState {
+    Empty,          // 空缓冲区
+    Filling,        // 填充中
+    Ready,          // 准备就绪
+    Full,           // 缓冲区满
+    Draining,       // 排空中
+    Error           // 错误状态
+};
+
+/**
+ * 缓冲区类型枚举
+ */
+enum class BufferType {
+    Audio,          // 音频缓冲区
+    Video,          // 视频缓冲区
+    Subtitle,       // 字幕缓冲区
+    Packet,         // 数据包缓冲区
+    Frame           // 帧缓冲区
+};
+
+/**
+ * 缓冲策略枚举
+ */
+enum class BufferStrategy {
+    FixedSize,      // 固定大小
+    DynamicSize,    // 动态大小
+    TimeBased,      // 基于时间
+    AdaptiveSize    // 自适应大小
+};
+
+} // namespace Core
+
+namespace Types {
+
+/**
+ * 缓冲区配置
+ */
+struct BufferConfig {
+    Core::BufferType type;              // 缓冲区类型
+    Core::BufferStrategy strategy;      // 缓冲策略
+    size_t maxSize;                     // 最大大小（字节）
+    size_t minSize;                     // 最小大小（字节）
+    int maxCount;                       // 最大数量
+    int minCount;                       // 最小数量
+    std::chrono::milliseconds maxDuration;     // 最大时长
+    std::chrono::milliseconds minDuration;     // 最小时长
+    double lowWaterMark;                // 低水位标记（0.0-1.0）
+    double highWaterMark;               // 高水位标记（0.0-1.0）
+    bool enablePreallocation;           // 启用预分配
+    bool enableMemoryPool;              // 启用内存池
+    
+    BufferConfig() {
+        type = Core::BufferType::Audio;
+        strategy = Core::BufferStrategy::FixedSize;
+        maxSize = 1024 * 1024;  // 1MB
+        minSize = 64 * 1024;    // 64KB
+        maxCount = 100;
+        minCount = 10;
+        maxDuration = std::chrono::milliseconds(5000);  // 5秒
+        minDuration = std::chrono::milliseconds(1000);  // 1秒
+        lowWaterMark = 0.2;
+        highWaterMark = 0.8;
+        enablePreallocation = true;
+        enableMemoryPool = true;
+    }
+};
+
+/**
+ * 缓冲区统计信息
+ */
+struct BufferStats {
+    Core::BufferType type;              // 缓冲区类型
+    Core::BufferState state;            // 当前状态
+    size_t currentSize;                 // 当前大小（字节）
+    size_t maxSize;                     // 最大大小（字节）
+    int currentCount;                   // 当前数量
+    int maxCount;                       // 最大数量
+    std::chrono::milliseconds currentDuration;  // 当前时长
+    std::chrono::milliseconds maxDuration;      // 最大时长
+    double fillLevel;                   // 填充级别（0.0-1.0）
+    double utilizationRate;             // 利用率（0.0-1.0）
+    int underrunCount;                  // 下溢次数
+    int overrunCount;                   // 上溢次数
+    double averageInputRate;            // 平均输入速率（字节/秒）
+    double averageOutputRate;           // 平均输出速率（字节/秒）
+    std::chrono::microseconds lastInputTime;    // 最后输入时间
+    std::chrono::microseconds lastOutputTime;   // 最后输出时间
+    
+    BufferStats() {
+        type = Core::BufferType::Audio;
+        state = Core::BufferState::Empty;
+        currentSize = 0;
+        maxSize = 0;
+        currentCount = 0;
+        maxCount = 0;
+        currentDuration = std::chrono::milliseconds(0);
+        maxDuration = std::chrono::milliseconds(0);
+        fillLevel = 0.0;
+        utilizationRate = 0.0;
+        underrunCount = 0;
+        overrunCount = 0;
+        averageInputRate = 0.0;
+        averageOutputRate = 0.0;
+        lastInputTime = std::chrono::microseconds(0);
+        lastOutputTime = std::chrono::microseconds(0);
+    }
+};
+
+/**
+ * 缓冲区项目信息
+ */
+struct BufferItem {
+    std::string id;                     // 项目ID
+    std::shared_ptr<void> data;         // 数据指针
+    size_t size;                        // 数据大小
+    std::chrono::microseconds timestamp;        // 时间戳
+    std::chrono::microseconds duration;         // 持续时间
+    int priority;                       // 优先级
+    std::map<std::string, std::string> metadata;  // 元数据
+    
+    BufferItem() {
+        size = 0;
+        timestamp = std::chrono::microseconds(0);
+        duration = std::chrono::microseconds(0);
+        priority = 0;
+    }
+};
+
+/**
+ * 内存池统计信息
+ */
+struct MemoryPoolStats {
+    size_t totalAllocated;              // 总分配内存
+    size_t totalUsed;                   // 总使用内存
+    size_t totalFree;                   // 总空闲内存
+    int allocationCount;                // 分配次数
+    int deallocationCount;              // 释放次数
+    int poolHitCount;                   // 池命中次数
+    int poolMissCount;                  // 池未命中次数
+    double fragmentationRatio;          // 碎片率
+    
+    MemoryPoolStats() {
+        totalAllocated = 0;
+        totalUsed = 0;
+        totalFree = 0;
+        allocationCount = 0;
+        deallocationCount = 0;
+        poolHitCount = 0;
+        poolMissCount = 0;
+        fragmentationRatio = 0.0;
+    }
+};
+
+} // namespace Types
+
+namespace Core {
+
+/**
+ * 缓冲区管理器抽象接口
+ * 提供统一的缓冲区管理功能
+ */
+class IBufferManager {
+public:
+    virtual ~IBufferManager() = default;
+
+    /**
+     * 初始化缓冲区管理器
+     * @param configs 缓冲区配置列表
+     * @return 是否初始化成功
+     */
+    virtual bool initialize(const std::vector<Types::BufferConfig>& configs) = 0;
+
+    /**
+     * 释放缓冲区管理器
+     */
+    virtual void release() = 0;
+
+    /**
+     * 启动缓冲区管理器
+     * @return 是否启动成功
+     */
+    virtual bool start() = 0;
+
+    /**
+     * 停止缓冲区管理器
+     */
+    virtual void stop() = 0;
+
+    /**
+     * 重置所有缓冲区
+     */
+    virtual void reset() = 0;
+
+    // ========== 缓冲区操作 ==========
+    
+    /**
+     * 创建缓冲区
+     * @param name 缓冲区名称
+     * @param config 缓冲区配置
+     * @return 是否创建成功
+     */
+    virtual bool createBuffer(const std::string& name, const Types::BufferConfig& config) = 0;
+
+    /**
+     * 销毁缓冲区
+     * @param name 缓冲区名称
+     * @return 是否销毁成功
+     */
+    virtual bool destroyBuffer(const std::string& name) = 0;
+
+    /**
+     * 清空缓冲区
+     * @param name 缓冲区名称
+     * @return 是否清空成功
+     */
+    virtual bool clearBuffer(const std::string& name) = 0;
+
+    /**
+     * 调整缓冲区大小
+     * @param name 缓冲区名称
+     * @param newConfig 新配置
+     * @return 是否调整成功
+     */
+    virtual bool resizeBuffer(const std::string& name, const Types::BufferConfig& newConfig) = 0;
+
+    // ========== 数据操作 ==========
+    
+    /**
+     * 向缓冲区写入数据
+     * @param name 缓冲区名称
+     * @param item 缓冲区项目
+     * @param blocking 是否阻塞等待
+     * @return 是否写入成功
+     */
+    virtual bool writeData(const std::string& name, const Types::BufferItem& item, bool blocking = false) = 0;
+
+    /**
+     * 从缓冲区读取数据
+     * @param name 缓冲区名称
+     * @param item 输出的缓冲区项目
+     * @param blocking 是否阻塞等待
+     * @return 是否读取成功
+     */
+    virtual bool readData(const std::string& name, Types::BufferItem& item, bool blocking = false) = 0;
+
+    /**
+     * 预览缓冲区数据（不移除）
+     * @param name 缓冲区名称
+     * @param item 输出的缓冲区项目
+     * @param index 预览索引（0为最前面）
+     * @return 是否预览成功
+     */
+    virtual bool peekData(const std::string& name, Types::BufferItem& item, int index = 0) = 0;
+
+    /**
+     * 跳过指定数量的数据项
+     * @param name 缓冲区名称
+     * @param count 跳过数量
+     * @return 实际跳过的数量
+     */
+    virtual int skipData(const std::string& name, int count) = 0;
+
+    /**
+     * 根据时间戳跳转
+     * @param name 缓冲区名称
+     * @param timestamp 目标时间戳
+     * @return 是否跳转成功
+     */
+    virtual bool seekToTimestamp(const std::string& name, std::chrono::microseconds timestamp) = 0;
+
+    // ========== 状态查询 ==========
+    
+    /**
+     * 获取缓冲区状态
+     * @param name 缓冲区名称
+     * @return 缓冲区状态
+     */
+    virtual BufferState getBufferState(const std::string& name) = 0;
+
+    /**
+     * 获取缓冲区统计信息
+     * @param name 缓冲区名称
+     * @return 统计信息
+     */
+    virtual Types::BufferStats getBufferStats(const std::string& name) = 0;
+
+    /**
+     * 获取所有缓冲区统计信息
+     * @return 所有缓冲区统计信息
+     */
+    virtual std::vector<Types::BufferStats> getAllBufferStats() = 0;
+
+    /**
+     * 检查缓冲区是否存在
+     * @param name 缓冲区名称
+     * @return 是否存在
+     */
+    virtual bool hasBuffer(const std::string& name) = 0;
+
+    /**
+     * 检查缓冲区是否为空
+     * @param name 缓冲区名称
+     * @return 是否为空
+     */
+    virtual bool isEmpty(const std::string& name) = 0;
+
+    /**
+     * 检查缓冲区是否已满
+     * @param name 缓冲区名称
+     * @return 是否已满
+     */
+    virtual bool isFull(const std::string& name) = 0;
+
+    /**
+     * 检查缓冲区是否达到低水位
+     * @param name 缓冲区名称
+     * @return 是否达到低水位
+     */
+    virtual bool isLowWaterMark(const std::string& name) = 0;
+
+    /**
+     * 检查缓冲区是否达到高水位
+     * @param name 缓冲区名称
+     * @return 是否达到高水位
+     */
+    virtual bool isHighWaterMark(const std::string& name) = 0;
+
+    /**
+     * 获取缓冲区可用空间
+     * @param name 缓冲区名称
+     * @return 可用空间（字节）
+     */
+    virtual size_t getAvailableSpace(const std::string& name) = 0;
+
+    /**
+     * 获取缓冲区已用空间
+     * @param name 缓冲区名称
+     * @return 已用空间（字节）
+     */
+    virtual size_t getUsedSpace(const std::string& name) = 0;
+
+    /**
+     * 获取缓冲区数据项数量
+     * @param name 缓冲区名称
+     * @return 数据项数量
+     */
+    virtual int getItemCount(const std::string& name) = 0;
+
+    /**
+     * 获取缓冲区时长
+     * @param name 缓冲区名称
+     * @return 缓冲区时长
+     */
+    virtual std::chrono::milliseconds getBufferDuration(const std::string& name) = 0;
+
+    // ========== 内存池管理 ==========
+    
+    /**
+     * 启用内存池
+     * @param enable 是否启用
+     */
+    virtual void enableMemoryPool(bool enable) = 0;
+
+    /**
+     * 获取内存池统计信息
+     * @return 内存池统计信息
+     */
+    virtual Types::MemoryPoolStats getMemoryPoolStats() = 0;
+
+    /**
+     * 清理内存池
+     */
+    virtual void cleanupMemoryPool() = 0;
+
+    /**
+     * 预分配内存
+     * @param size 预分配大小（字节）
+     * @param count 预分配数量
+     * @return 是否预分配成功
+     */
+    virtual bool preallocateMemory(size_t size, int count) = 0;
+
+    // ========== 回调设置 ==========
+    
+    /**
+     * 设置缓冲区状态变化回调
+     * @param callback 状态变化回调函数
+     */
+    virtual void setBufferStateChangedCallback(
+        std::function<void(const std::string&, BufferState, BufferState)> callback) = 0;
+
+    /**
+     * 设置低水位回调
+     * @param callback 低水位回调函数
+     */
+    virtual void setLowWaterMarkCallback(
+        std::function<void(const std::string&)> callback) = 0;
+
+    /**
+     * 设置高水位回调
+     * @param callback 高水位回调函数
+     */
+    virtual void setHighWaterMarkCallback(
+        std::function<void(const std::string&)> callback) = 0;
+
+    /**
+     * 设置缓冲区满回调
+     * @param callback 缓冲区满回调函数
+     */
+    virtual void setBufferFullCallback(
+        std::function<void(const std::string&)> callback) = 0;
+
+    /**
+     * 设置缓冲区空回调
+     * @param callback 缓冲区空回调函数
+     */
+    virtual void setBufferEmptyCallback(
+        std::function<void(const std::string&)> callback) = 0;
+
+    /**
+     * 设置错误回调
+     * @param callback 错误回调函数
+     */
+    virtual void setErrorCallback(
+        std::function<void(const std::string&, const std::string&)> callback) = 0;
+};
+
+/**
+ * 缓冲区管理器工厂接口
+ */
+class IBufferManagerFactory {
+public:
+    virtual ~IBufferManagerFactory() = default;
+
+    /**
+     * 创建缓冲区管理器实例
+     * @param name 管理器名称
+     * @return 缓冲区管理器智能指针
+     */
+    virtual std::unique_ptr<IBufferManager> createBufferManager(const std::string& name = "") = 0;
+
+    /**
+     * 获取默认缓冲区配置
+     * @param type 缓冲区类型
+     * @return 默认配置
+     */
+    virtual Types::BufferConfig getDefaultConfig(BufferType type) = 0;
+
+    /**
+     * 获取推荐的缓冲区大小
+     * @param type 缓冲区类型
+     * @return 推荐大小（字节）
+     */
+    virtual size_t getRecommendedBufferSize(BufferType type) = 0;
+};
+
+} // namespace Core
+} // namespace AVPlayer2
+
+#endif // IBUFFERMANAGER_H

AvPlayer2/interfaces/IMediaDecoder.h

@@ -0,0 +1,232 @@
+#ifndef IMEDIADECODER_H
+#define IMEDIADECODER_H
+
+#include <functional>
+#include <memory>
+#include <vector>
+#include <string>
+
+namespace AVPlayer2 {
+namespace Core {
+
+/**
+ * 解码器状态枚举
+ */
+enum class DecoderState {
+    Idle,       // 空闲状态
+    Decoding,   // 解码中
+    Paused,     // 暂停状态
+    Stopped,    // 停止状态
+    Error       // 错误状态
+};
+
+/**
+ * 媒体类型枚举
+ */
+enum class MediaType {
+    Audio,      // 音频
+    Video,      // 视频
+    Subtitle    // 字幕
+};
+
+/**
+ * 解码器类型枚举
+ */
+enum class DecoderType {
+    Software,   // 软件解码
+    Hardware    // 硬件解码
+};
+
+} // namespace Core
+
+namespace Types {
+
+/**
+ * 媒体包数据
+ */
+struct MediaPacket {
+    unsigned char* data;        // 数据指针
+    int size;                   // 数据大小
+    double timestamp;           // 时间戳（秒）
+    int64_t pts;               // 显示时间戳
+    int64_t dts;               // 解码时间戳
+    int streamIndex;           // 流索引
+    bool isKeyFrame;           // 是否关键帧
+    Core::MediaType mediaType; // 媒体类型
+};
+
+/**
+ * 解码器配置
+ */
+struct DecoderConfig {
+    Core::DecoderType type;     // 解码器类型
+    std::string codecName;      // 编解码器名称
+    int threadCount;            // 线程数
+    bool enableHardwareAccel;   // 是否启用硬件加速
+    std::string hwAccelDevice;  // 硬件加速设备
+};
+
+/**
+ * 解码统计信息
+ */
+struct DecoderStats {
+    int framesDecoded;          // 已解码帧数
+    int framesDropped;          // 丢弃帧数
+    double averageDecodeTime;   // 平均解码时间（毫秒）
+    double currentFps;          // 当前解码帧率
+};
+
+} // namespace Types
+
+namespace Core {
+
+/**
+ * 媒体解码器抽象接口
+ * 提供与平台无关的媒体解码功能
+ */
+class IMediaDecoder {
+public:
+    virtual ~IMediaDecoder() = default;
+
+    /**
+     * 初始化解码器
+     * @param config 解码器配置
+     * @return 是否初始化成功
+     */
+    virtual bool initialize(const Types::DecoderConfig& config) = 0;
+
+    /**
+     * 开始解码
+     * @return 是否开始成功
+     */
+    virtual bool start() = 0;
+
+    /**
+     * 停止解码
+     */
+    virtual void stop() = 0;
+
+    /**
+     * 暂停解码
+     */
+    virtual void pause() = 0;
+
+    /**
+     * 恢复解码
+     */
+    virtual void resume() = 0;
+
+    /**
+     * 输入媒体包进行解码
+     * @param packet 媒体包数据
+     * @return 是否输入成功
+     */
+    virtual bool inputPacket(const Types::MediaPacket& packet) = 0;
+
+    /**
+     * 获取解码后的音频帧
+     * @param audioFrame 输出音频帧数据
+     * @return 是否获取成功
+     */
+    virtual bool getAudioFrame(Types::AudioFrame& audioFrame) = 0;
+
+    /**
+     * 获取解码后的视频帧
+     * @param videoFrame 输出视频帧数据
+     * @return 是否获取成功
+     */
+    virtual bool getVideoFrame(Types::VideoFrame& videoFrame) = 0;
+
+    /**
+     * 刷新解码器缓冲区
+     */
+    virtual void flush() = 0;
+
+    /**
+     * 重置解码器
+     */
+    virtual void reset() = 0;
+
+    /**
+     * 获取当前状态
+     * @return 解码器状态
+     */
+    virtual DecoderState getState() const = 0;
+
+    /**
+     * 获取支持的媒体类型
+     * @return 支持的媒体类型列表
+     */
+    virtual std::vector<MediaType> getSupportedMediaTypes() const = 0;
+
+    /**
+     * 检查是否支持硬件加速
+     * @return 是否支持硬件加速
+     */
+    virtual bool isHardwareAccelSupported() const = 0;
+
+    /**
+     * 获取解码统计信息
+     * @return 解码统计信息
+     */
+    virtual Types::DecoderStats getStats() const = 0;
+
+    /**
+     * 设置状态变化回调
+     * @param callback 状态变化回调函数
+     */
+    virtual void setStateCallback(std::function<void(DecoderState)> callback) = 0;
+
+    /**
+     * 设置帧解码完成回调
+     * @param callback 帧解码完成回调函数
+     */
+    virtual void setFrameDecodedCallback(std::function<void(MediaType, double)> callback) = 0;
+
+    /**
+     * 设置解码错误回调
+     * @param callback 解码错误回调函数
+     */
+    virtual void setErrorCallback(std::function<void(const std::string&)> callback) = 0;
+};
+
+/**
+ * 媒体解码器工厂接口
+ */
+class IMediaDecoderFactory {
+public:
+    virtual ~IMediaDecoderFactory() = default;
+
+    /**
+     * 创建解码器实例
+     * @param mediaType 媒体类型
+     * @return 解码器智能指针
+     */
+    virtual std::unique_ptr<IMediaDecoder> createDecoder(MediaType mediaType) = 0;
+
+    /**
+     * 获取支持的编解码器列表
+     * @param mediaType 媒体类型
+     * @return 支持的编解码器名称列表
+     */
+    virtual std::vector<std::string> getSupportedCodecs(MediaType mediaType) = 0;
+
+    /**
+     * 检查是否支持指定编解码器
+     * @param codecName 编解码器名称
+     * @param mediaType 媒体类型
+     * @return 是否支持
+     */
+    virtual bool isCodecSupported(const std::string& codecName, MediaType mediaType) = 0;
+
+    /**
+     * 获取可用的硬件加速设备列表
+     * @return 硬件加速设备名称列表
+     */
+    virtual std::vector<std::string> getAvailableHwAccelDevices() = 0;
+};
+
+} // namespace Core
+} // namespace AVPlayer2
+
+#endif // IMEDIADECODER_H

AvPlayer2/interfaces/IPlayerController.h

@@ -0,0 +1,560 @@
+#ifndef IPLAYERCONTROLLER_H
+#define IPLAYERCONTROLLER_H
+
+#include <string>
+#include <memory>
+#include <functional>
+#include <chrono>
+#include <vector>
+#include <map>
+
+namespace AVPlayer2 {
+namespace Core {
+
+/**
+ * 播放器状态枚举
+ */
+enum class PlayerState {
+    Stopped,        // 停止状态
+    Loading,        // 加载中
+    Loaded,         // 已加载
+    Playing,        // 播放中
+    Paused,         // 暂停
+    Seeking,        // 跳转中
+    Buffering,      // 缓冲中
+    Error           // 错误状态
+};
+
+/**
+ * 播放模式枚举
+ */
+enum class PlayMode {
+    Normal,         // 正常播放
+    Loop,           // 循环播放
+    Shuffle,        // 随机播放
+    RepeatOne       // 单曲循环
+};
+
+/**
+ * 缩放模式枚举
+ */
+enum class ScaleMode {
+    Fit,            // 适应窗口
+    Fill,           // 填充窗口
+    Stretch,        // 拉伸
+    Original,       // 原始大小
+    Custom          // 自定义
+};
+
+} // namespace Core
+
+namespace Types {
+
+/**
+ * 播放器配置
+ */
+struct PlayerConfig {
+    bool enableHardwareDecoding;       // 启用硬件解码
+    bool enableAudioOutput;            // 启用音频输出
+    bool enableVideoOutput;            // 启用视频输出
+    bool enableSubtitles;              // 启用字幕
+    int maxVideoFrameBuffer;           // 最大视频帧缓冲
+    int maxAudioFrameBuffer;           // 最大音频帧缓冲
+    double seekAccuracy;               // 跳转精度（秒）
+    bool autoPlay;                     // 自动播放
+    double defaultVolume;              // 默认音量（0.0-1.0）
+    Core::PlayMode defaultPlayMode;    // 默认播放模式
+    Core::ScaleMode defaultScaleMode;  // 默认缩放模式
+    std::string userAgent;             // 用户代理
+    int networkTimeout;                // 网络超时（毫秒）
+    
+    PlayerConfig() {
+        enableHardwareDecoding = true;
+        enableAudioOutput = true;
+        enableVideoOutput = true;
+        enableSubtitles = true;
+        maxVideoFrameBuffer = 10;
+        maxAudioFrameBuffer = 20;
+        seekAccuracy = 1.0;
+        autoPlay = false;
+        defaultVolume = 1.0;
+        defaultPlayMode = Core::PlayMode::Normal;
+        defaultScaleMode = Core::ScaleMode::Fit;
+        userAgent = "AVPlayer2/1.0";
+        networkTimeout = 30000;
+    }
+};
+
+/**
+ * 播放器统计信息
+ */
+struct PlayerStats {
+    std::chrono::microseconds totalDuration;   // 总时长
+    std::chrono::microseconds currentPosition; // 当前位置
+    double playbackSpeed;                      // 播放速度
+    int videoFrameRate;                        // 视频帧率
+    int audioSampleRate;                       // 音频采样率
+    int videoBitrate;                          // 视频比特率
+    int audioBitrate;                          // 音频比特率
+    int droppedFrames;                         // 丢弃帧数
+    int renderedFrames;                        // 渲染帧数
+    double bufferHealth;                       // 缓冲健康度（0.0-1.0）
+    std::string videoCodec;                    // 视频编解码器
+    std::string audioCodec;                    // 音频编解码器
+    
+    PlayerStats() {
+        totalDuration = std::chrono::microseconds(0);
+        currentPosition = std::chrono::microseconds(0);
+        playbackSpeed = 1.0;
+        videoFrameRate = 0;
+        audioSampleRate = 0;
+        videoBitrate = 0;
+        audioBitrate = 0;
+        droppedFrames = 0;
+        renderedFrames = 0;
+        bufferHealth = 0.0;
+    }
+};
+
+/**
+ * 播放列表项
+ */
+struct PlaylistItem {
+    std::string id;                 // 项目ID
+    std::string url;                // 媒体URL
+    std::string title;              // 标题
+    std::string artist;             // 艺术家
+    std::string album;              // 专辑
+    std::chrono::microseconds duration;  // 时长
+    std::map<std::string, std::string> metadata;  // 元数据
+    
+    PlaylistItem() {
+        duration = std::chrono::microseconds(0);
+    }
+};
+
+/**
+ * 字幕信息
+ */
+struct SubtitleTrack {
+    int index;                      // 轨道索引
+    std::string language;           // 语言
+    std::string title;              // 标题
+    std::string codec;              // 编解码器
+    bool isDefault;                 // 是否默认
+    bool isForced;                  // 是否强制
+    
+    SubtitleTrack() {
+        index = -1;
+        isDefault = false;
+        isForced = false;
+    }
+};
+
+/**
+ * 音频轨道信息
+ */
+struct AudioTrack {
+    int index;                      // 轨道索引
+    std::string language;           // 语言
+    std::string title;              // 标题
+    std::string codec;              // 编解码器
+    int channels;                   // 声道数
+    int sampleRate;                 // 采样率
+    int bitrate;                    // 比特率
+    bool isDefault;                 // 是否默认
+    
+    AudioTrack() {
+        index = -1;
+        channels = 0;
+        sampleRate = 0;
+        bitrate = 0;
+        isDefault = false;
+    }
+};
+
+} // namespace Types
+
+namespace Core {
+
+/**
+ * 播放器控制器抽象接口
+ * 提供完整的媒体播放控制功能
+ */
+class IPlayerController {
+public:
+    virtual ~IPlayerController() = default;
+
+    /**
+     * 初始化播放器
+     * @param config 播放器配置
+     * @return 是否初始化成功
+     */
+    virtual bool initialize(const Types::PlayerConfig& config) = 0;
+
+    /**
+     * 释放播放器资源
+     */
+    virtual void release() = 0;
+
+    // ========== 媒体加载 ==========
+    
+    /**
+     * 加载媒体文件
+     * @param url 媒体文件URL或路径
+     * @return 是否开始加载
+     */
+    virtual bool loadMedia(const std::string& url) = 0;
+
+    /**
+     * 卸载当前媒体
+     */
+    virtual void unloadMedia() = 0;
+
+    // ========== 播放控制 ==========
+    
+    /**
+     * 开始播放
+     * @return 是否开始播放
+     */
+    virtual bool play() = 0;
+
+    /**
+     * 暂停播放
+     */
+    virtual void pause() = 0;
+
+    /**
+     * 停止播放
+     */
+    virtual void stop() = 0;
+
+    /**
+     * 跳转到指定位置
+     * @param position 目标位置（微秒）
+     * @return 是否开始跳转
+     */
+    virtual bool seekTo(std::chrono::microseconds position) = 0;
+
+    /**
+     * 相对跳转
+     * @param offset 偏移量（微秒，正数向前，负数向后）
+     * @return 是否开始跳转
+     */
+    virtual bool seekBy(std::chrono::microseconds offset) = 0;
+
+    // ========== 播放参数 ==========
+    
+    /**
+     * 设置播放速度
+     * @param speed 播放速度（1.0为正常速度）
+     */
+    virtual void setPlaybackSpeed(double speed) = 0;
+
+    /**
+     * 获取播放速度
+     * @return 当前播放速度
+     */
+    virtual double getPlaybackSpeed() const = 0;
+
+    /**
+     * 设置音量
+     * @param volume 音量（0.0-1.0）
+     */
+    virtual void setVolume(double volume) = 0;
+
+    /**
+     * 获取音量
+     * @return 当前音量
+     */
+    virtual double getVolume() const = 0;
+
+    /**
+     * 设置静音
+     * @param muted 是否静音
+     */
+    virtual void setMuted(bool muted) = 0;
+
+    /**
+     * 获取静音状态
+     * @return 是否静音
+     */
+    virtual bool isMuted() const = 0;
+
+    // ========== 状态查询 ==========
+    
+    /**
+     * 获取播放器状态
+     * @return 当前状态
+     */
+    virtual PlayerState getState() const = 0;
+
+    /**
+     * 获取当前播放位置
+     * @return 当前位置（微秒）
+     */
+    virtual std::chrono::microseconds getCurrentPosition() const = 0;
+
+    /**
+     * 获取媒体总时长
+     * @return 总时长（微秒）
+     */
+    virtual std::chrono::microseconds getDuration() const = 0;
+
+    /**
+     * 获取缓冲进度
+     * @return 缓冲进度（0.0-1.0）
+     */
+    virtual double getBufferProgress() const = 0;
+
+    /**
+     * 是否可以播放
+     * @return 是否可以播放
+     */
+    virtual bool canPlay() const = 0;
+
+    /**
+     * 是否可以暂停
+     * @return 是否可以暂停
+     */
+    virtual bool canPause() const = 0;
+
+    /**
+     * 是否可以跳转
+     * @return 是否可以跳转
+     */
+    virtual bool canSeek() const = 0;
+
+    // ========== 轨道管理 ==========
+    
+    /**
+     * 获取音频轨道列表
+     * @return 音频轨道列表
+     */
+    virtual std::vector<Types::AudioTrack> getAudioTracks() const = 0;
+
+    /**
+     * 获取字幕轨道列表
+     * @return 字幕轨道列表
+     */
+    virtual std::vector<Types::SubtitleTrack> getSubtitleTracks() const = 0;
+
+    /**
+     * 选择音频轨道
+     * @param index 轨道索引
+     * @return 是否选择成功
+     */
+    virtual bool selectAudioTrack(int index) = 0;
+
+    /**
+     * 选择字幕轨道
+     * @param index 轨道索引（-1表示关闭字幕）
+     * @return 是否选择成功
+     */
+    virtual bool selectSubtitleTrack(int index) = 0;
+
+    /**
+     * 获取当前音频轨道索引
+     * @return 当前音频轨道索引
+     */
+    virtual int getCurrentAudioTrack() const = 0;
+
+    /**
+     * 获取当前字幕轨道索引
+     * @return 当前字幕轨道索引
+     */
+    virtual int getCurrentSubtitleTrack() const = 0;
+
+    // ========== 播放列表 ==========
+    
+    /**
+     * 设置播放模式
+     * @param mode 播放模式
+     */
+    virtual void setPlayMode(PlayMode mode) = 0;
+
+    /**
+     * 获取播放模式
+     * @return 当前播放模式
+     */
+    virtual PlayMode getPlayMode() const = 0;
+
+    /**
+     * 添加播放列表项
+     * @param item 播放列表项
+     * @return 是否添加成功
+     */
+    virtual bool addPlaylistItem(const Types::PlaylistItem& item) = 0;
+
+    /**
+     * 移除播放列表项
+     * @param index 项目索引
+     * @return 是否移除成功
+     */
+    virtual bool removePlaylistItem(int index) = 0;
+
+    /**
+     * 清空播放列表
+     */
+    virtual void clearPlaylist() = 0;
+
+    /**
+     * 获取播放列表
+     * @return 播放列表
+     */
+    virtual std::vector<Types::PlaylistItem> getPlaylist() const = 0;
+
+    /**
+     * 播放指定项目
+     * @param index 项目索引
+     * @return 是否开始播放
+     */
+    virtual bool playItem(int index) = 0;
+
+    /**
+     * 播放下一项
+     * @return 是否开始播放
+     */
+    virtual bool playNext() = 0;
+
+    /**
+     * 播放上一项
+     * @return 是否开始播放
+     */
+    virtual bool playPrevious() = 0;
+
+    /**
+     * 获取当前播放项索引
+     * @return 当前播放项索引
+     */
+    virtual int getCurrentPlaylistIndex() const = 0;
+
+    // ========== 视频控制 ==========
+    
+    /**
+     * 设置视频缩放模式
+     * @param mode 缩放模式
+     */
+    virtual void setScaleMode(ScaleMode mode) = 0;
+
+    /**
+     * 获取视频缩放模式
+     * @return 当前缩放模式
+     */
+    virtual ScaleMode getScaleMode() const = 0;
+
+    /**
+     * 设置视频旋转角度
+     * @param angle 旋转角度（度）
+     */
+    virtual void setRotation(int angle) = 0;
+
+    /**
+     * 获取视频旋转角度
+     * @return 当前旋转角度
+     */
+    virtual int getRotation() const = 0;
+
+    // ========== 统计信息 ==========
+    
+    /**
+     * 获取播放器统计信息
+     * @return 统计信息
+     */
+    virtual Types::PlayerStats getStats() const = 0;
+
+    /**
+     * 重置统计信息
+     */
+    virtual void resetStats() = 0;
+
+    // ========== 回调设置 ==========
+    
+    /**
+     * 设置状态变化回调
+     * @param callback 状态变化回调函数
+     */
+    virtual void setStateChangedCallback(
+        std::function<void(PlayerState, PlayerState)> callback) = 0;
+
+    /**
+     * 设置位置变化回调
+     * @param callback 位置变化回调函数
+     */
+    virtual void setPositionChangedCallback(
+        std::function<void(std::chrono::microseconds)> callback) = 0;
+
+    /**
+     * 设置时长变化回调
+     * @param callback 时长变化回调函数
+     */
+    virtual void setDurationChangedCallback(
+        std::function<void(std::chrono::microseconds)> callback) = 0;
+
+    /**
+     * 设置缓冲进度回调
+     * @param callback 缓冲进度回调函数
+     */
+    virtual void setBufferProgressCallback(
+        std::function<void(double)> callback) = 0;
+
+    /**
+     * 设置媒体加载完成回调
+     * @param callback 媒体加载完成回调函数
+     */
+    virtual void setMediaLoadedCallback(
+        std::function<void(const std::string&)> callback) = 0;
+
+    /**
+     * 设置播放完成回调
+     * @param callback 播放完成回调函数
+     */
+    virtual void setPlaybackFinishedCallback(
+        std::function<void()> callback) = 0;
+
+    /**
+     * 设置错误回调
+     * @param callback 错误回调函数
+     */
+    virtual void setErrorCallback(
+        std::function<void(const std::string&, const std::string&)> callback) = 0;
+};
+
+/**
+ * 播放器控制器工厂接口
+ */
+class IPlayerControllerFactory {
+public:
+    virtual ~IPlayerControllerFactory() = default;
+
+    /**
+     * 创建播放器控制器实例
+     * @param name 控制器名称
+     * @return 播放器控制器智能指针
+     */
+    virtual std::unique_ptr<IPlayerController> createPlayerController(const std::string& name = "") = 0;
+
+    /**
+     * 获取默认播放器配置
+     * @return 默认配置
+     */
+    virtual Types::PlayerConfig getDefaultConfig() = 0;
+
+    /**
+     * 获取支持的媒体格式列表
+     * @return 支持的格式列表
+     */
+    virtual std::vector<std::string> getSupportedFormats() = 0;
+
+    /**
+     * 检查是否支持指定格式
+     * @param format 媒体格式
+     * @return 是否支持
+     */
+    virtual bool isFormatSupported(const std::string& format) = 0;
+};
+
+} // namespace Core
+} // namespace AVPlayer2
+
+#endif // IPLAYERCONTROLLER_H

AvPlayer2/interfaces/ISyncController.h

@@ -0,0 +1,356 @@
+#ifndef ISYNCCONTROLLER_H
+#define ISYNCCONTROLLER_H
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <string>
+
+namespace AVPlayer2 {
+namespace Core {
+
+/**
+ * 同步状态枚举
+ */
+enum class SyncState {
+    Stopped,        // 停止状态
+    Running,        // 运行状态
+    Paused,         // 暂停状态
+    Seeking,        // 跳转状态
+    Buffering       // 缓冲状态
+};
+
+/**
+ * 同步模式枚举
+ */
+enum class SyncMode {
+    AudioMaster,    // 以音频为主时钟
+    VideoMaster,    // 以视频为主时钟
+    ExternalMaster, // 以外部时钟为主
+    FreeRun         // 自由运行模式
+};
+
+/**
+ * 时钟类型枚举
+ */
+enum class ClockType {
+    Audio,          // 音频时钟
+    Video,          // 视频时钟
+    External,       // 外部时钟
+    System          // 系统时钟
+};
+
+} // namespace Core
+
+namespace Types {
+
+/**
+ * 时间戳信息
+ */
+struct TimestampInfo {
+    std::chrono::microseconds pts;          // 显示时间戳
+    std::chrono::microseconds dts;          // 解码时间戳
+    std::chrono::microseconds duration;     // 持续时间
+    std::chrono::system_clock::time_point systemTime;  // 系统时间
+    double timeBase;                        // 时间基准
+    
+    TimestampInfo() {
+        pts = std::chrono::microseconds(0);
+        dts = std::chrono::microseconds(0);
+        duration = std::chrono::microseconds(0);
+        systemTime = std::chrono::system_clock::now();
+        timeBase = 1.0;
+    }
+};
+
+/**
+ * 时钟信息
+ */
+struct ClockInfo {
+    Core::ClockType type;                   // 时钟类型
+    std::chrono::microseconds currentTime;  // 当前时间
+    std::chrono::microseconds lastUpdate;   // 最后更新时间
+    double speed;                           // 播放速度
+    bool isPaused;                          // 是否暂停
+    double drift;                           // 时钟漂移
+    
+    ClockInfo() {
+        type = Core::ClockType::System;
+        currentTime = std::chrono::microseconds(0);
+        lastUpdate = std::chrono::microseconds(0);
+        speed = 1.0;
+        isPaused = false;
+        drift = 0.0;
+    }
+};
+
+/**
+ * 同步统计信息
+ */
+struct SyncStats {
+    double audioVideoDelay;         // 音视频延迟（毫秒）
+    double averageDelay;            // 平均延迟
+    double maxDelay;                // 最大延迟
+    double minDelay;                // 最小延迟
+    int droppedFrames;              // 丢弃帧数
+    int duplicatedFrames;           // 重复帧数
+    int syncAdjustments;            // 同步调整次数
+    double clockDrift;              // 时钟漂移
+    
+    SyncStats() {
+        audioVideoDelay = 0.0;
+        averageDelay = 0.0;
+        maxDelay = 0.0;
+        minDelay = 0.0;
+        droppedFrames = 0;
+        duplicatedFrames = 0;
+        syncAdjustments = 0;
+        clockDrift = 0.0;
+    }
+};
+
+/**
+ * 同步配置
+ */
+struct SyncConfig {
+    Core::SyncMode mode;                    // 同步模式
+    double maxAudioDelay;                   // 最大音频延迟（毫秒）
+    double maxVideoDelay;                   // 最大视频延迟（毫秒）
+    double syncThreshold;                   // 同步阈值（毫秒）
+    bool enableFrameDrop;                   // 是否启用丢帧
+    bool enableFrameDuplication;            // 是否启用重复帧
+    double speedAdjustmentRange;            // 速度调整范围
+    int maxConsecutiveDrops;                // 最大连续丢帧数
+    
+    SyncConfig() {
+        mode = Core::SyncMode::AudioMaster;
+        maxAudioDelay = 100.0;
+        maxVideoDelay = 100.0;
+        syncThreshold = 40.0;
+        enableFrameDrop = true;
+        enableFrameDuplication = false;
+        speedAdjustmentRange = 0.1;
+        maxConsecutiveDrops = 5;
+    }
+};
+
+} // namespace Types
+
+namespace Core {
+
+/**
+ * 同步控制器抽象接口
+ * 提供音视频同步功能
+ */
+class ISyncController {
+public:
+    virtual ~ISyncController() = default;
+
+    /**
+     * 初始化同步控制器
+     * @param config 同步配置
+     * @return 是否初始化成功
+     */
+    virtual bool initialize(const Types::SyncConfig& config) = 0;
+
+    /**
+     * 启动同步控制器
+     * @return 是否启动成功
+     */
+    virtual bool start() = 0;
+
+    /**
+     * 停止同步控制器
+     */
+    virtual void stop() = 0;
+
+    /**
+     * 暂停同步
+     */
+    virtual void pause() = 0;
+
+    /**
+     * 恢复同步
+     */
+    virtual void resume() = 0;
+
+    /**
+     * 重置同步状态
+     */
+    virtual void reset() = 0;
+
+    /**
+     * 设置同步模式
+     * @param mode 同步模式
+     */
+    virtual void setSyncMode(SyncMode mode) = 0;
+
+    /**
+     * 获取同步模式
+     * @return 当前同步模式
+     */
+    virtual SyncMode getSyncMode() const = 0;
+
+    /**
+     * 设置播放速度
+     * @param speed 播放速度（1.0为正常速度）
+     */
+    virtual void setPlaybackSpeed(double speed) = 0;
+
+    /**
+     * 获取播放速度
+     * @return 当前播放速度
+     */
+    virtual double getPlaybackSpeed() const = 0;
+
+    /**
+     * 更新音频时钟
+     * @param timestamp 时间戳信息
+     */
+    virtual void updateAudioClock(const Types::TimestampInfo& timestamp) = 0;
+
+    /**
+     * 更新视频时钟
+     * @param timestamp 时间戳信息
+     */
+    virtual void updateVideoClock(const Types::TimestampInfo& timestamp) = 0;
+
+    /**
+     * 更新外部时钟
+     * @param timestamp 时间戳信息
+     */
+    virtual void updateExternalClock(const Types::TimestampInfo& timestamp) = 0;
+
+    /**
+     * 获取主时钟时间
+     * @return 主时钟当前时间（微秒）
+     */
+    virtual std::chrono::microseconds getMasterClockTime() = 0;
+
+    /**
+     * 获取指定类型时钟信息
+     * @param type 时钟类型
+     * @return 时钟信息
+     */
+    virtual Types::ClockInfo getClockInfo(ClockType type) = 0;
+
+    /**
+     * 计算音频延迟
+     * @param audioTimestamp 音频时间戳
+     * @return 延迟时间（毫秒）
+     */
+    virtual double calculateAudioDelay(const Types::TimestampInfo& audioTimestamp) = 0;
+
+    /**
+     * 计算视频延迟
+     * @param videoTimestamp 视频时间戳
+     * @return 延迟时间（毫秒）
+     */
+    virtual double calculateVideoDelay(const Types::TimestampInfo& videoTimestamp) = 0;
+
+    /**
+     * 判断是否应该丢弃视频帧
+     * @param videoTimestamp 视频时间戳
+     * @return 是否应该丢弃
+     */
+    virtual bool shouldDropVideoFrame(const Types::TimestampInfo& videoTimestamp) = 0;
+
+    /**
+     * 判断是否应该重复视频帧
+     * @param videoTimestamp 视频时间戳
+     * @return 是否应该重复
+     */
+    virtual bool shouldDuplicateVideoFrame(const Types::TimestampInfo& videoTimestamp) = 0;
+
+    /**
+     * 计算音频样本调整
+     * @param audioTimestamp 音频时间戳
+     * @param sampleCount 样本数
+     * @return 调整后的样本数
+     */
+    virtual int calculateAudioSampleAdjustment(const Types::TimestampInfo& audioTimestamp, 
+                                               int sampleCount) = 0;
+
+    /**
+     * 跳转到指定时间
+     * @param seekTime 目标时间（微秒）
+     */
+    virtual void seekTo(std::chrono::microseconds seekTime) = 0;
+
+    /**
+     * 获取同步状态
+     * @return 同步状态
+     */
+    virtual SyncState getState() const = 0;
+
+    /**
+     * 获取同步统计信息
+     * @return 统计信息
+     */
+    virtual Types::SyncStats getStats() const = 0;
+
+    /**
+     * 重置统计信息
+     */
+    virtual void resetStats() = 0;
+
+    /**
+     * 设置同步状态变化回调
+     * @param callback 状态变化回调函数
+     */
+    virtual void setStateChangedCallback(
+        std::function<void(SyncState)> callback) = 0;
+
+    /**
+     * 设置时钟更新回调
+     * @param callback 时钟更新回调函数
+     */
+    virtual void setClockUpdateCallback(
+        std::function<void(ClockType, const Types::ClockInfo&)> callback) = 0;
+
+    /**
+     * 设置同步调整回调
+     * @param callback 同步调整回调函数
+     */
+    virtual void setSyncAdjustmentCallback(
+        std::function<void(const std::string&, double)> callback) = 0;
+
+    /**
+     * 设置错误回调
+     * @param callback 错误回调函数
+     */
+    virtual void setErrorCallback(
+        std::function<void(const std::string&, const std::string&)> callback) = 0;
+};
+
+/**
+ * 同步控制器工厂接口
+ */
+class ISyncControllerFactory {
+public:
+    virtual ~ISyncControllerFactory() = default;
+
+    /**
+     * 创建同步控制器实例
+     * @param name 控制器名称
+     * @return 同步控制器智能指针
+     */
+    virtual std::unique_ptr<ISyncController> createSyncController(const std::string& name = "") = 0;
+
+    /**
+     * 获取默认同步配置
+     * @return 默认配置
+     */
+    virtual Types::SyncConfig getDefaultConfig() = 0;
+
+    /**
+     * 获取支持的同步模式列表
+     * @return 支持的同步模式
+     */
+    virtual std::vector<SyncMode> getSupportedSyncModes() = 0;
+};
+
+} // namespace Core
+} // namespace AVPlayer2
+
+#endif // ISYNCCONTROLLER_H

AvPlayer2/interfaces/IThreadPool.h

@@ -0,0 +1,286 @@
+#ifndef ITHREADPOOL_H
+#define ITHREADPOOL_H
+
+#include <functional>
+#include <memory>
+#include <future>
+#include <chrono>
+#include <string>
+
+namespace AVPlayer2 {
+namespace Core {
+
+/**
+ * 线程池状态枚举
+ */
+enum class ThreadPoolState {
+    Stopped,    // 停止状态
+    Running,    // 运行状态
+    Stopping    // 正在停止
+};
+
+/**
+ * 任务优先级枚举
+ */
+enum class TaskPriority {
+    Low,        // 低优先级
+    Normal,     // 普通优先级
+    High,       // 高优先级
+    Critical    // 关键优先级
+};
+
+/**
+ * 任务状态枚举
+ */
+enum class TaskState {
+    Pending,    // 等待执行
+    Running,    // 正在执行
+    Completed,  // 已完成
+    Cancelled,  // 已取消
+    Failed      // 执行失败
+};
+
+} // namespace Core
+
+namespace Types {
+
+/**
+ * 任务信息
+ */
+struct TaskInfo {
+    std::string taskId;                     // 任务ID
+    std::string taskName;                   // 任务名称
+    Core::TaskPriority priority;            // 任务优先级
+    Core::TaskState state;                  // 任务状态
+    std::chrono::system_clock::time_point createTime;  // 创建时间
+    std::chrono::system_clock::time_point startTime;   // 开始时间
+    std::chrono::system_clock::time_point endTime;     // 结束时间
+    std::string threadId;                   // 执行线程ID
+    std::string errorMessage;               // 错误信息
+    
+    TaskInfo() {
+        priority = Core::TaskPriority::Normal;
+        state = Core::TaskState::Pending;
+        createTime = std::chrono::system_clock::now();
+    }
+};
+
+/**
+ * 线程池统计信息
+ */
+struct ThreadPoolStats {
+    int totalThreads;           // 总线程数
+    int activeThreads;          // 活跃线程数
+    int idleThreads;            // 空闲线程数
+    int pendingTasks;           // 等待任务数
+    int completedTasks;         // 已完成任务数
+    int failedTasks;            // 失败任务数
+    double averageTaskTime;     // 平均任务执行时间（毫秒）
+    double threadUtilization;   // 线程利用率（0.0-1.0）
+    
+    ThreadPoolStats() {
+        totalThreads = 0;
+        activeThreads = 0;
+        idleThreads = 0;
+        pendingTasks = 0;
+        completedTasks = 0;
+        failedTasks = 0;
+        averageTaskTime = 0.0;
+        threadUtilization = 0.0;
+    }
+};
+
+/**
+ * 线程池配置
+ */
+struct ThreadPoolConfig {
+    int minThreads;             // 最小线程数
+    int maxThreads;             // 最大线程数
+    int maxQueueSize;           // 最大队列大小
+    std::chrono::milliseconds keepAliveTime;   // 线程保活时间
+    bool allowCoreThreadTimeout;               // 是否允许核心线程超时
+    std::string threadNamePrefix;              // 线程名称前缀
+    
+    ThreadPoolConfig() {
+        minThreads = 2;
+        maxThreads = 8;
+        maxQueueSize = 100;
+        keepAliveTime = std::chrono::milliseconds(60000);
+        allowCoreThreadTimeout = false;
+        threadNamePrefix = "AVPlayer2-Thread-";
+    }
+};
+
+} // namespace Types
+
+namespace Core {
+
+/**
+ * 线程池抽象接口
+ * 提供与平台无关的线程池功能
+ */
+class IThreadPool {
+public:
+    virtual ~IThreadPool() = default;
+
+    /**
+     * 初始化线程池
+     * @param config 线程池配置
+     * @return 是否初始化成功
+     */
+    virtual bool initialize(const Types::ThreadPoolConfig& config) = 0;
+
+    /**
+     * 启动线程池
+     * @return 是否启动成功
+     */
+    virtual bool start() = 0;
+
+    /**
+     * 停止线程池
+     * @param waitForCompletion 是否等待所有任务完成
+     */
+    virtual void stop(bool waitForCompletion = true) = 0;
+
+    /**
+     * 提交任务（无返回值）
+     * @param task 任务函数
+     * @param priority 任务优先级
+     * @param taskName 任务名称
+     * @return 任务ID
+     */
+    virtual std::string submitTask(std::function<void()> task, 
+                                   TaskPriority priority = TaskPriority::Normal,
+                                   const std::string& taskName = "") = 0;
+
+    /**
+     * 提交任务（有返回值）
+     * @param task 任务函数
+     * @param priority 任务优先级
+     * @param taskName 任务名称
+     * @return 任务结果的future对象
+     */
+    template<typename F, typename... Args>
+    auto submitTaskWithResult(F&& task, TaskPriority priority = TaskPriority::Normal,
+                              const std::string& taskName = "") 
+        -> std::future<typename std::result_of<F(Args...)>::type> {
+        using ReturnType = typename std::result_of<F(Args...)>::type;
+        
+        auto taskPtr = std::make_shared<std::packaged_task<ReturnType()>>(
+            std::bind(std::forward<F>(task))
+        );
+        
+        std::future<ReturnType> result = taskPtr->get_future();
+        
+        submitTask([taskPtr](){ (*taskPtr)(); }, priority, taskName);
+        
+        return result;
+    }
+
+    /**
+     * 取消任务
+     * @param taskId 任务ID
+     * @return 是否取消成功
+     */
+    virtual bool cancelTask(const std::string& taskId) = 0;
+
+    /**
+     * 等待任务完成
+     * @param taskId 任务ID
+     * @param timeout 超时时间（毫秒，-1表示无限等待）
+     * @return 是否在超时前完成
+     */
+    virtual bool waitForTask(const std::string& taskId, int timeout = -1) = 0;
+
+    /**
+     * 等待所有任务完成
+     * @param timeout 超时时间（毫秒，-1表示无限等待）
+     * @return 是否在超时前完成
+     */
+    virtual bool waitForAllTasks(int timeout = -1) = 0;
+
+    /**
+     * 获取任务信息
+     * @param taskId 任务ID
+     * @return 任务信息
+     */
+    virtual Types::TaskInfo getTaskInfo(const std::string& taskId) = 0;
+
+    /**
+     * 获取线程池状态
+     * @return 线程池状态
+     */
+    virtual ThreadPoolState getState() const = 0;
+
+    /**
+     * 获取线程池统计信息
+     * @return 统计信息
+     */
+    virtual Types::ThreadPoolStats getStats() const = 0;
+
+    /**
+     * 调整线程池大小
+     * @param newSize 新的线程数
+     * @return 是否调整成功
+     */
+    virtual bool resize(int newSize) = 0;
+
+    /**
+     * 清空任务队列
+     * @return 被清空的任务数
+     */
+    virtual int clearQueue() = 0;
+
+    /**
+     * 设置任务完成回调
+     * @param callback 任务完成回调函数
+     */
+    virtual void setTaskCompletedCallback(
+        std::function<void(const std::string&, TaskState)> callback) = 0;
+
+    /**
+     * 设置线程池状态变化回调
+     * @param callback 状态变化回调函数
+     */
+    virtual void setStateChangedCallback(
+        std::function<void(ThreadPoolState)> callback) = 0;
+
+    /**
+     * 设置错误回调
+     * @param callback 错误回调函数
+     */
+    virtual void setErrorCallback(
+        std::function<void(const std::string&, const std::string&)> callback) = 0;
+};
+
+/**
+ * 线程池工厂接口
+ */
+class IThreadPoolFactory {
+public:
+    virtual ~IThreadPoolFactory() = default;
+
+    /**
+     * 创建线程池实例
+     * @param name 线程池名称
+     * @return 线程池智能指针
+     */
+    virtual std::unique_ptr<IThreadPool> createThreadPool(const std::string& name = "") = 0;
+
+    /**
+     * 获取默认线程池配置
+     * @return 默认配置
+     */
+    virtual Types::ThreadPoolConfig getDefaultConfig() = 0;
+
+    /**
+     * 获取推荐的线程数
+     * @return 推荐线程数
+     */
+    virtual int getRecommendedThreadCount() = 0;
+};
+
+} // namespace Core
+} // namespace AVPlayer2
+
+#endif // ITHREADPOOL_H

AvPlayer2/interfaces/IVideoRenderer.h

@@ -0,0 +1,210 @@
+#ifndef IVIDEORENDERER_H
+#define IVIDEORENDERER_H
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+namespace AVPlayer2 {
+namespace Core {
+
+/**
+ * 视频渲染器状态枚举
+ */
+enum class VideoRendererState {
+    Stopped,    // 停止状态
+    Playing,    // 播放状态
+    Paused,     // 暂停状态
+    Error       // 错误状态
+};
+
+/**
+ * 视频像素格式枚举
+ */
+enum class PixelFormat {
+    RGB24,      // RGB 24位
+    RGB32,      // RGB 32位
+    YUV420P,    // YUV 4:2:0 平面格式
+    YUV422P,    // YUV 4:2:2 平面格式
+    YUV444P,    // YUV 4:4:4 平面格式
+    NV12,       // NV12 格式
+    NV21        // NV21 格式
+};
+
+} // namespace Core
+
+namespace Types {
+
+/**
+ * 视频格式参数
+ */
+struct VideoFormat {
+    int width;                          // 视频宽度
+    int height;                         // 视频高度
+    Core::PixelFormat pixelFormat;      // 像素格式
+    float frameRate;                    // 帧率
+    int bitRate;                        // 比特率
+};
+
+/**
+ * 视频帧数据
+ */
+struct VideoFrame {
+    unsigned char* data[4];             // 视频数据平面指针
+    int lineSize[4];                    // 每个平面的行大小
+    int width;                          // 帧宽度
+    int height;                         // 帧高度
+    Core::PixelFormat pixelFormat;      // 像素格式
+    double timestamp;                   // 时间戳（秒）
+    int64_t pts;                        // 显示时间戳
+};
+
+/**
+ * 渲染区域
+ */
+struct RenderRect {
+    int x;          // X坐标
+    int y;          // Y坐标
+    int width;      // 宽度
+    int height;     // 高度
+};
+
+} // namespace Types
+
+namespace Core {
+
+/**
+ * 视频渲染器抽象接口
+ * 提供与平台无关的视频输出功能
+ */
+class IVideoRenderer {
+public:
+    virtual ~IVideoRenderer() = default;
+
+    /**
+     * 初始化视频渲染器
+     * @param format 视频格式参数
+     * @return 是否初始化成功
+     */
+    virtual bool initialize(const Types::VideoFormat& format) = 0;
+
+    /**
+     * 开始渲染
+     * @return 是否开始成功
+     */
+    virtual bool start() = 0;
+
+    /**
+     * 停止渲染
+     */
+    virtual void stop() = 0;
+
+    /**
+     * 暂停渲染
+     */
+    virtual void pause() = 0;
+
+    /**
+     * 恢复渲染
+     */
+    virtual void resume() = 0;
+
+    /**
+     * 渲染视频帧
+     * @param frame 视频帧数据
+     * @return 是否渲染成功
+     */
+    virtual bool renderFrame(const Types::VideoFrame& frame) = 0;
+
+    /**
+     * 设置渲染区域
+     * @param rect 渲染区域
+     */
+    virtual void setRenderRect(const Types::RenderRect& rect) = 0;
+
+    /**
+     * 获取渲染区域
+     * @return 当前渲染区域
+     */
+    virtual Types::RenderRect getRenderRect() const = 0;
+
+    /**
+     * 设置缩放模式
+     * @param keepAspectRatio 是否保持宽高比
+     */
+    virtual void setScaleMode(bool keepAspectRatio) = 0;
+
+    /**
+     * 获取当前状态
+     * @return 渲染器状态
+     */
+    virtual VideoRendererState getState() const = 0;
+
+    /**
+     * 获取渲染统计信息
+     * @param framesRendered 已渲染帧数
+     * @param framesDropped 丢弃帧数
+     */
+    virtual void getRenderStats(int& framesRendered, int& framesDropped) const = 0;
+
+    /**
+     * 清空渲染缓冲区
+     */
+    virtual void clearBuffer() = 0;
+
+    /**
+     * 设置状态变化回调
+     * @param callback 状态变化回调函数
+     */
+    virtual void setStateCallback(std::function<void(VideoRendererState)> callback) = 0;
+
+    /**
+     * 设置帧渲染完成回调
+     * @param callback 帧渲染完成回调函数
+     */
+    virtual void setFrameRenderedCallback(std::function<void(const Types::VideoFrame&)> callback) = 0;
+
+    /**
+     * 设置渲染错误回调
+     * @param callback 渲染错误回调函数
+     */
+    virtual void setErrorCallback(std::function<void(const std::string&)> callback) = 0;
+};
+
+/**
+ * 视频渲染器工厂接口
+ */
+class IVideoRendererFactory {
+public:
+    virtual ~IVideoRendererFactory() = default;
+
+    /**
+     * 创建视频渲染器实例
+     * @return 视频渲染器智能指针
+     */
+    virtual std::unique_ptr<IVideoRenderer> createRenderer() = 0;
+
+    /**
+     * 获取支持的视频格式列表
+     * @return 支持的视频格式列表
+     */
+    virtual std::vector<Types::VideoFormat> getSupportedFormats() = 0;
+
+    /**
+     * 检查是否支持指定格式
+     * @param format 视频格式
+     * @return 是否支持
+     */
+    virtual bool isFormatSupported(const Types::VideoFormat& format) = 0;
+
+    /**
+     * 获取支持的像素格式列表
+     * @return 支持的像素格式列表
+     */
+    virtual std::vector<PixelFormat> getSupportedPixelFormats() = 0;
+};
+
+} // namespace Core
+} // namespace AVPlayer2
+
+#endif // IVIDEORENDERER_H

AvPlayer2/types/ErrorCodes.h

@@ -0,0 +1,205 @@
+#ifndef ERRORCODES_H
+#define ERRORCODES_H
+
+#include <string>
+#include <unordered_map>
+
+namespace AVPlayer2 {
+namespace Types {
+
+/**
+ * 错误码枚举
+ * 使用分类编码：模块(2位) + 类别(2位) + 具体错误(4位)
+ */
+enum class ErrorCode {
+    // 成功
+    Success = 0,
+    
+    // 通用错误 (01xx)
+    UnknownError = 0100,
+    InvalidParameter = 0101,
+    OutOfMemory = 0102,
+    NotImplemented = 0103,
+    NotSupported = 0104,
+    Timeout = 0105,
+    
+    // 文件/IO错误 (02xx)
+    FileNotFound = 0200,
+    FileOpenFailed = 0201,
+    FileReadFailed = 0202,
+    FileWriteFailed = 0203,
+    FileFormatNotSupported = 0204,
+    FileCorrupted = 0205,
+    NetworkError = 0206,
+    
+    // 解码器错误 (03xx)
+    DecoderInitFailed = 0300,
+    DecoderNotFound = 0301,
+    DecodeFailed = 0302,
+    CodecNotSupported = 0303,
+    HardwareAccelFailed = 0304,
+    DecoderConfigError = 0305,
+    
+    // 渲染器错误 (04xx)
+    RendererInitFailed = 0400,
+    RenderFailed = 0401,
+    AudioDeviceError = 0402,
+    VideoDeviceError = 0403,
+    BufferUnderrun = 0404,
+    BufferOverrun = 0405,
+    FormatConversionFailed = 0406,
+    
+    // 播放器错误 (05xx)
+    PlayerNotInitialized = 0500,
+    PlayerAlreadyPlaying = 0501,
+    PlayerNotPlaying = 0502,
+    SeekFailed = 0503,
+    StreamNotFound = 0504,
+    SyncError = 0505,
+    
+    // 线程错误 (06xx)
+    ThreadCreateFailed = 0600,
+    ThreadStartFailed = 0601,
+    ThreadStopFailed = 0602,
+    ThreadSyncError = 0603,
+    DeadlockDetected = 0604,
+    
+    // 内存错误 (07xx)
+    MemoryAllocationFailed = 0700,
+    MemoryLeakDetected = 0701,
+    BufferTooSmall = 0702,
+    BufferOverflow = 0703,
+    
+    // 配置错误 (08xx)
+    ConfigLoadFailed = 0800,
+    ConfigSaveFailed = 0801,
+    ConfigInvalid = 0802,
+    ConfigMissing = 0803,
+    
+    // 网络错误 (09xx)
+    NetworkConnectionFailed = 0900,
+    NetworkTimeout = 0901,
+    NetworkProtocolError = 0902,
+    NetworkAuthFailed = 0903,
+    NetworkDataCorrupted = 0904
+};
+
+/**
+ * 错误严重级别
+ */
+enum class ErrorSeverity {
+    Info,       // 信息
+    Warning,    // 警告
+    Error,      // 错误
+    Critical,   // 严重错误
+    Fatal       // 致命错误
+};
+
+/**
+ * 错误类别
+ */
+enum class ErrorCategory {
+    General,    // 通用
+    IO,         // 输入输出
+    Decoder,    // 解码器
+    Renderer,   // 渲染器
+    Player,     // 播放器
+    Thread,     // 线程
+    Memory,     // 内存
+    Config,     // 配置
+    Network     // 网络
+};
+
+/**
+ * 错误信息详情
+ */
+struct ErrorDetail {
+    ErrorCode code;
+    ErrorSeverity severity;
+    ErrorCategory category;
+    std::string message;
+    std::string description;
+    std::string solution;
+    
+    ErrorDetail(ErrorCode c, ErrorSeverity s, ErrorCategory cat, 
+                const std::string& msg, const std::string& desc = "", 
+                const std::string& sol = "")
+        : code(c), severity(s), category(cat), message(msg), description(desc), solution(sol) {}
+};
+
+/**
+ * 错误码管理器
+ */
+class ErrorCodeManager {
+public:
+    /**
+     * 获取错误信息
+     * @param code 错误码
+     * @return 错误详情
+     */
+    static ErrorDetail getErrorDetail(ErrorCode code);
+    
+    /**
+     * 获取错误消息
+     * @param code 错误码
+     * @return 错误消息字符串
+     */
+    static std::string getErrorMessage(ErrorCode code);
+    
+    /**
+     * 获取错误严重级别
+     * @param code 错误码
+     * @return 错误严重级别
+     */
+    static ErrorSeverity getErrorSeverity(ErrorCode code);
+    
+    /**
+     * 获取错误类别
+     * @param code 错误码
+     * @return 错误类别
+     */
+    static ErrorCategory getErrorCategory(ErrorCode code);
+    
+    /**
+     * 检查是否为成功状态
+     * @param code 错误码
+     * @return 是否成功
+     */
+    static bool isSuccess(ErrorCode code) {
+        return code == ErrorCode::Success;
+    }
+    
+    /**
+     * 检查是否为错误状态
+     * @param code 错误码
+     * @return 是否为错误
+     */
+    static bool isError(ErrorCode code) {
+        return code != ErrorCode::Success;
+    }
+    
+    /**
+     * 检查是否为致命错误
+     * @param code 错误码
+     * @return 是否为致命错误
+     */
+    static bool isFatal(ErrorCode code) {
+        return getErrorSeverity(code) == ErrorSeverity::Fatal;
+    }
+    
+private:
+    static std::unordered_map<ErrorCode, ErrorDetail> s_errorMap;
+    static void initializeErrorMap();
+    static bool s_initialized;
+};
+
+// 便利宏定义
+#define AVPLAYER2_SUCCESS(code) AVPlayer2::Types::ErrorCodeManager::isSuccess(code)
+#define AVPLAYER2_ERROR(code) AVPlayer2::Types::ErrorCodeManager::isError(code)
+#define AVPLAYER2_FATAL(code) AVPlayer2::Types::ErrorCodeManager::isFatal(code)
+#define AVPLAYER2_ERROR_MSG(code) AVPlayer2::Types::ErrorCodeManager::getErrorMessage(code)
+
+} // namespace Types
+} // namespace AVPlayer2
+
+#endif // ERRORCODES_H

AvPlayer2/types/MediaTypes.h

@@ -0,0 +1,214 @@
+#ifndef MEDIATYPES_H
+#define MEDIATYPES_H
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace AVPlayer2 {
+namespace Types {
+
+// 常量定义
+const int MAX_AUDIO_CHANNELS = 8;
+const int MAX_VIDEO_PLANES = 4;
+const int DEFAULT_SAMPLE_RATE = 44100;
+const int DEFAULT_BUFFER_SIZE = 4096;
+const float DEFAULT_VOLUME = 1.0f;
+const double INVALID_TIMESTAMP = -1.0;
+
+/**
+ * 音频采样格式枚举
+ */
+enum class AudioSampleFormat {
+    Unknown,        // 未知格式
+    UInt8,          // 8位无符号整数
+    Int16,          // 16位有符号整数
+    Int32,          // 32位有符号整数
+    Float32,        // 32位浮点数
+    Float64,        // 64位浮点数
+    UInt8Planar,    // 8位无符号整数平面格式
+    Int16Planar,    // 16位有符号整数平面格式
+    Int32Planar,    // 32位有符号整数平面格式
+    Float32Planar,  // 32位浮点数平面格式
+    Float64Planar   // 64位浮点数平面格式
+};
+
+/**
+ * 音频帧数据
+ */
+struct AudioFrame {
+    unsigned char* data[MAX_AUDIO_CHANNELS];    // 音频数据平面指针
+    int lineSize[MAX_AUDIO_CHANNELS];           // 每个平面的数据大小
+    int sampleRate;                             // 采样率
+    int channels;                               // 声道数
+    int samplesPerChannel;                      // 每声道采样数
+    AudioSampleFormat sampleFormat;             // 采样格式
+    double timestamp;                           // 时间戳（秒）
+    int64_t pts;                               // 显示时间戳
+    bool isPlanar;                             // 是否为平面格式
+    
+    AudioFrame() {
+        for (int i = 0; i < MAX_AUDIO_CHANNELS; ++i) {
+            data[i] = nullptr;
+            lineSize[i] = 0;
+        }
+        sampleRate = DEFAULT_SAMPLE_RATE;
+        channels = 2;
+        samplesPerChannel = 0;
+        sampleFormat = AudioSampleFormat::Int16;
+        timestamp = INVALID_TIMESTAMP;
+        pts = 0;
+        isPlanar = false;
+    }
+};
+
+/**
+ * 字幕帧数据
+ */
+struct SubtitleFrame {
+    std::string text;           // 字幕文本
+    double startTime;           // 开始时间（秒）
+    double endTime;             // 结束时间（秒）
+    double timestamp;           // 时间戳（秒）
+    int x;                      // X坐标
+    int y;                      // Y坐标
+    int width;                  // 宽度
+    int height;                 // 高度
+    std::string fontFamily;     // 字体族
+    int fontSize;               // 字体大小
+    std::string fontColor;      // 字体颜色
+    std::string backgroundColor; // 背景颜色
+    bool isBold;                // 是否粗体
+    bool isItalic;              // 是否斜体
+    
+    SubtitleFrame() {
+        startTime = INVALID_TIMESTAMP;
+        endTime = INVALID_TIMESTAMP;
+        timestamp = INVALID_TIMESTAMP;
+        x = 0;
+        y = 0;
+        width = 0;
+        height = 0;
+        fontSize = 16;
+        fontColor = "#FFFFFF";
+        backgroundColor = "#000000";
+        isBold = false;
+        isItalic = false;
+    }
+};
+
+/**
+ * 媒体流信息
+ */
+struct StreamInfo {
+    int index;                  // 流索引
+    std::string codecName;      // 编解码器名称
+    std::string codecLongName;  // 编解码器长名称
+    int64_t duration;           // 持续时间（微秒）
+    int64_t bitRate;            // 比特率
+    std::string language;       // 语言
+    std::string title;          // 标题
+    
+    // 音频流特有属性
+    int sampleRate;             // 采样率
+    int channels;               // 声道数
+    AudioSampleFormat sampleFormat; // 采样格式
+    
+    // 视频流特有属性
+    int width;                  // 宽度
+    int height;                 // 高度
+    float frameRate;            // 帧率
+    float aspectRatio;          // 宽高比
+    
+    StreamInfo() {
+        index = -1;
+        duration = 0;
+        bitRate = 0;
+        sampleRate = 0;
+        channels = 0;
+        sampleFormat = AudioSampleFormat::Unknown;
+        width = 0;
+        height = 0;
+        frameRate = 0.0f;
+        aspectRatio = 0.0f;
+    }
+};
+
+/**
+ * 媒体文件信息
+ */
+struct MediaInfo {
+    std::string fileName;               // 文件名
+    std::string formatName;             // 格式名称
+    std::string formatLongName;         // 格式长名称
+    int64_t duration;                   // 总持续时间（微秒）
+    int64_t fileSize;                   // 文件大小（字节）
+    int64_t bitRate;                    // 总比特率
+    std::vector<StreamInfo> audioStreams;   // 音频流列表
+    std::vector<StreamInfo> videoStreams;   // 视频流列表
+    std::vector<StreamInfo> subtitleStreams; // 字幕流列表
+    std::string metadata;               // 元数据（JSON格式）
+    
+    MediaInfo() {
+        duration = 0;
+        fileSize = 0;
+        bitRate = 0;
+    }
+};
+
+/**
+ * 播放状态信息
+ */
+struct PlaybackInfo {
+    double currentTime;         // 当前播放时间（秒）
+    double duration;            // 总时长（秒）
+    double bufferProgress;      // 缓冲进度（0.0-1.0）
+    bool isPlaying;             // 是否正在播放
+    bool isPaused;              // 是否暂停
+    bool isMuted;               // 是否静音
+    float volume;               // 音量（0.0-1.0）
+    float playbackSpeed;        // 播放速度
+    int currentAudioStream;     // 当前音频流索引
+    int currentVideoStream;     // 当前视频流索引
+    int currentSubtitleStream;  // 当前字幕流索引
+    
+    PlaybackInfo() {
+        currentTime = 0.0;
+        duration = 0.0;
+        bufferProgress = 0.0;
+        isPlaying = false;
+        isPaused = false;
+        isMuted = false;
+        volume = DEFAULT_VOLUME;
+        playbackSpeed = 1.0f;
+        currentAudioStream = -1;
+        currentVideoStream = -1;
+        currentSubtitleStream = -1;
+    }
+};
+
+/**
+ * 错误信息
+ */
+struct ErrorInfo {
+    int code;                   // 错误码
+    std::string message;        // 错误消息
+    std::string detail;         // 详细信息
+    double timestamp;           // 发生时间戳
+    std::string component;      // 发生错误的组件
+    
+    ErrorInfo() {
+        code = 0;
+        timestamp = 0.0;
+    }
+    
+    ErrorInfo(int errorCode, const std::string& errorMessage) 
+        : code(errorCode), message(errorMessage) {
+        timestamp = 0.0; // 应该设置为当前时间
+    }
+};
+
+} // namespace Types
+} // namespace AVPlayer2
+
+#endif // MEDIATYPES_H