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");
    
    // 初始化FFmpeg
    if (!initializeFFmpeg()) {
        av::Logger::instance().error("Failed to initialize FFmpeg");
        setState(PlayerState::Error);
        return;
    }
    
    // 创建队列
    m_packetQueue = av::utils::PacketQueueFactory::createStandardQueue(1000);  // 最多1000个包
    m_videoFrameQueue = av::utils::FrameQueueFactory::createStandardQueue(30); // 最多30帧
    m_audioFrameQueue = av::utils::FrameQueueFactory::createStandardQueue(100); // 最多100帧
    
    // 创建同步器
    m_synchronizer = std::make_unique<Synchronizer>();
    
    // 创建线程管理器
    m_threadManager = std::make_unique<ThreadManager>();
    
    // 创建解码器
    m_videoDecoder = std::make_unique<VideoDecoder>();
    m_audioDecoder = std::make_unique<AudioDecoder>();
    
    // 创建音频输出设备
    m_audioOutput = std::make_unique<AudioOutput>();
    
    m_initialized = true;
    av::Logger::instance().info("PlayerCore initialized successfully");
}

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_eventCallback) {
        m_eventCallback->onMediaInfoChanged(m_mediaInfo);
    }
    
    av::Logger::instance().info("File opened successfully: " + filename);
    return ErrorCode::OK;
}

ErrorCode PlayerCore::play()
{
    av::Logger::instance().info("Starting playback");
    
    if (m_state == PlayerState::Playing) {
        av::Logger::instance().debug("Already playing");
        return ErrorCode::OK;
    }
    
    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;
    }
    
    // 启动音频输出设备
    if (m_audioOutput && m_mediaInfo.hasAudio) {
        m_audioOutput->start();
    }
    
    // 启动读取线程
    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::OK;
}

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_audioOutput) {
        m_audioOutput->pause();
    }
    
    setState(PlayerState::Paused);
    av::Logger::instance().info("Playback paused");
    return ErrorCode::OK;
}

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::OK;
    }
    
    // 停止音频输出
    if (m_audioOutput) {
        m_audioOutput->stop();
    }
    
    // 清空视频渲染器
    if (m_videoRenderer) {
        m_videoRenderer->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::OK;
}

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;
    
    // 清空队列
    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::OK;
}

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_PARAMETER;
    }
    
    std::lock_guard<std::mutex> lock(m_mutex);
    m_playbackSpeed = speed;
    
    av::Logger::instance().info("Playback speed set to: " + std::to_string(speed));
    return ErrorCode::OK;
}

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
        );
    }
    
    if (m_mediaInfo.hasAudio) {
        success &= m_threadManager->createAudioDecodeThread(
            m_packetQueue.get(),
            m_audioFrameQueue.get(),
            m_audioDecoder.get(),
            m_synchronizer.get(),
            m_mediaInfo.audioStreamIndex
        );
    }
    
    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::OK) {
                av_packet_free(&packet);
            }
        } else {
            av_packet_free(&packet);
        }
    }
}

void PlayerCore::videoDecodeThreadFunc()
{
    // 视频解码线程实现
    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 = nullptr;
        packet = m_packetQueue ? m_packetQueue->dequeuePacket(1) : nullptr;
        if (packet) {
            if (m_videoDecoder) {
                AVPacketPtr packetPtr(packet);
                std::vector<AVFramePtr> frames;
                ErrorCode result = m_videoDecoder->decode(packetPtr, frames);
                if (result == ErrorCode::OK) {
                    for (auto& frame : frames) {
                        // 直接渲染到视频渲染器
                        if (m_videoRenderer && frame) {
                            m_videoRenderer->renderFrame(frame);
                        }
                        
                        // 同时放入队列供其他用途
                        if (m_videoFrameQueue) {
                            m_videoFrameQueue->enqueue(frame.release());
                        }
                    }
                }
            } else {
                av_packet_free(&packet);
            }
        } else {
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
        }
    }
}

void PlayerCore::audioDecodeThreadFunc()
{
    // 音频解码线程实现
    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 = nullptr;
        packet = m_packetQueue ? m_packetQueue->dequeuePacket(1) : nullptr;
        if (packet) {
            if (m_audioDecoder) {
                AVPacketPtr packetPtr(packet);
                std::vector<AVFramePtr> frames;
                ErrorCode result = m_audioDecoder->decode(packetPtr, frames);
                if (result == ErrorCode::OK) {
                    for (auto& frame : frames) {
                        // 直接输出到音频设备
                        if (m_audioOutput && frame && m_state == PlayerState::Playing) {
                            m_audioOutput->writeFrame(frame);
                        }
                        
                        // 同时放入队列供其他用途
                        if (m_audioFrameQueue) {
                            m_audioFrameQueue->enqueue(frame.release());
                        }
                    }
                }
            } else {
                av_packet_free(&packet);
            }
        } else {
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
        }
    }
}

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.pixelFormat = static_cast<AVPixelFormat>(videoStream->codecpar->format);
    params.hardwareAccel = false; // 默认软件解码
    params.threadCount = 4;
    
    ErrorCode result = m_videoDecoder->open(params);
    if (result != ErrorCode::OK) {
        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::OK) {
        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()
{
    // TODO: 实现当前播放时间计算
    return 0;
}

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::setVideoRenderer(VideoRenderer* renderer)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    m_videoRenderer = renderer;
    
    // 如果已有媒体信息且视频渲染器可用，初始化渲染器
    if (m_videoRenderer && m_mediaInfo.hasVideo) {
        AVStream* videoStream = m_formatContext->streams[m_mediaInfo.videoStreamIndex];
        m_videoRenderer->initialize(
            videoStream->codecpar->width,
            videoStream->codecpar->height,
            static_cast<AVPixelFormat>(videoStream->codecpar->format)
        );
    }
    
    av::Logger::instance().info("Video renderer set");
}

} // namespace player
} // namespace av