【ffmpeg 视频播放】深入探索：ffmpeg视频播放优化策略与设计模式的实践应用（二）

#include <unordered_map>
// 假设Frame是一个类，表示视频的一帧
class Frame {
    // ...
};
// 创建一个哈希表，键是帧号，值是帧数据
std::unordered_map<int, Frame> frameCache;

Frame getFrame(int frameNumber) {
    // 检查帧数据是否在缓存中
    auto it = frameCache.find(frameNumber);
    if (it != frameCache.end()) {
        // 如果在缓存中，直接返回缓存的数据
        return it->second;
    } else {
        // 如果不在缓存中，从磁盘或网络中加载数据
        Frame frame = loadFrameFromDiskOrNetwork(frameNumber);
        // 将加载的数据存储到缓存中
        frameCache[frameNumber] = frame;
        // 返回加载的数据
        return frame;
    }
}

// 策略接口
class OptimizationStrategy {
public:
    virtual void optimize() = 0;
};
// 具体策略：双缓冲优化
class DoubleBufferingStrategy : public OptimizationStrategy {
public:
    void optimize() override {
        // 实现双缓冲优化
    }
};
// 具体策略：备份优化
class BackupStrategy : public OptimizationStrategy {
public:
    void optimize() override {
        // 实现备份优化
    }
};
// 上下文
class Player {
private:
    OptimizationStrategy* strategy;  // 持有一个策略对象的引用
public:
    void setStrategy(OptimizationStrategy* strategy) {  // 设置策略
        this->strategy = strategy;
    }
    void play() {
        // 在播放视频之前执行优化
        strategy->optimize();
        // 播放视频...
    }
};

// 组件接口
class OptimizationStrategy {
public:
    virtual void optimize() = 0;
};
// 复合组件：可以包含多个子策略
class CompositeStrategy : public OptimizationStrategy {
private:
    std::vector<OptimizationStrategy*> strategies;  // 子策略列表
public:
    void addStrategy(OptimizationStrategy* strategy) {  // 添加子策略
        strategies.push_back(strategy);
    }
    void optimize() override {
        // 依次执行每个子策略的优化方法
        for (auto strategy : strategies) {
            strategy->optimize();
        }
    }
};

// 策略接口
class OptimizationStrategy {
public:
    virtual void optimize() = 0;
};
// 具体策略：双缓冲优化
class DoubleBufferingStrategy : public OptimizationStrategy {
public:
    void optimize() override {
        // 实现双缓冲优化
    }
};
// 具体策略：备份优化
class BackupStrategy : public OptimizationStrategy {
public:
    void optimize() override {
        // 实现备份优化
    }
};
// 工厂类
class StrategyFactory {
public:
    static OptimizationStrategy* createStrategy(const std::string& type) {
        if (type == "DoubleBuffering") {
            return new DoubleBufferingStrategy();
        } else if (type == "Backup") {
            return new BackupStrategy();
        } else {
            throw std::invalid_argument("Invalid strategy type");
        }
    }
};

// 观察者接口
class Observer {
public:
    virtual void update(int state) = 0;
};
// 具体观察者：优化策略
class OptimizationStrategy : public Observer {
public:
    void update(int state) override {
        // 根据状态更新优化策略
    }
};
// 主题接口
class Subject {
private:
    std::vector<Observer*> observers;  // 观察者列表
public:
    void addObserver(Observer* observer) {  // 添加观察者
        observers.push_back(observer);
    }
    void notifyObservers(int state) {  // 通知所有观察者
        for (auto observer : observers) {
            observer->update(state);
        }
    }
};
// 具体主题：播放器
class Player : public Subject {
public:
    void play() {
        // 播放视频...
        // 在播放过程中，如果状态发生改变，通知所有观察者
        notifyObservers(state);
    }
};