video-pc/AV/code/player/player_core.cpp

#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