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

#include "player_adapter.h"
#include "video_renderer.h"
#include "opengl_video_renderer.h"
#include "../base/media_common.h"
#include <QDebug>
#include <QMetaType>

namespace av {
namespace player {

// 注册Qt元类型
static int registerMetaTypes() {
    qRegisterMetaType<PlayerState>("PlayerState");
    qRegisterMetaType<MediaInfo>("MediaInfo");
    qRegisterMetaType<PlaybackStats>("PlaybackStats");
    qRegisterMetaType<av::ErrorCode>("av::ErrorCode");
    return 0;
}
static int dummy = registerMetaTypes();

PlayerAdapter::PlayerAdapter(QObject* parent)
    : QObject(parent)
    , m_playerCore(std::make_unique<PlayerCore>())
    , m_updateTimer(new QTimer(this))
{
    // 设置事件回调
    m_playerCore->setEventCallback(this);
    
    // 连接更新定时器
    connect(m_updateTimer, &QTimer::timeout, this, &PlayerAdapter::updatePlayer);
    
    qDebug() << "PlayerAdapter created";
}

PlayerAdapter::~PlayerAdapter()
{
    stopUpdateTimer();
    qDebug() << "PlayerAdapter destroyed";
}

void PlayerAdapter::setVideoRenderer(VideoRenderer* renderer)
{
    if (m_playerCore) {
        m_playerCore->setVideoRenderer(renderer);
        m_videoRenderer = renderer;
        updateRendererType();
    }
}

void PlayerAdapter::setOpenGLVideoRenderer(OpenGLVideoRenderer* renderer)
{
    if (m_playerCore) {
        m_playerCore->setOpenGLVideoRenderer(renderer);
        m_openGLVideoRenderer = renderer;
        updateRendererType();
        
        // 如果OpenGL渲染器初始化完成，发送信号
        if (renderer && renderer->isInitialized()) {
            emit openGLRendererInitialized();
        }
    }
}

av::ErrorCode PlayerAdapter::openFile(const QString& filename)
{
    std::string stdFilename = filename.toStdString();
    av::ErrorCode result = m_playerCore->openFile(stdFilename);
    
    if (result == av::ErrorCode::SUCCESS) {
        // 启动更新定时器
        startUpdateTimer();
        
        // 检查渲染器状态
        if (m_openGLVideoRenderer && m_openGLVideoRenderer->isInitialized()) {
            emit openGLRendererInitialized();
        }
        
        qDebug() << "File opened successfully:" << filename;
        qDebug() << "Current renderer type:" << m_currentRendererType;
    }
    
    return result;
}

av::ErrorCode PlayerAdapter::play()
{
    return m_playerCore->play();
}

av::ErrorCode PlayerAdapter::pause()
{
    return m_playerCore->pause();
}

av::ErrorCode PlayerAdapter::stop()
{
    av::ErrorCode result = m_playerCore->stop();
    
    if (result == av::ErrorCode::SUCCESS) {
        // 停止更新定时器
        stopUpdateTimer();
    }
    
    return result;
}

av::ErrorCode PlayerAdapter::seek(qint64 timestamp)
{
    return m_playerCore->seek(timestamp);
}

av::ErrorCode PlayerAdapter::setPlaybackSpeed(double speed)
{
    av::ErrorCode result = m_playerCore->setPlaybackSpeed(speed);
    
    if (result == av::ErrorCode::SUCCESS && std::abs(m_lastPlaybackSpeed - speed) > 0.001) {
        m_lastPlaybackSpeed = speed;
        emit playbackSpeedChanged(speed);
    }
    
    return result;
}

PlayerState PlayerAdapter::getState() const
{
    return m_playerCore->getState();
}

qint64 PlayerAdapter::getCurrentTime() const
{
    return m_playerCore->getCurrentTime();
}

qint64 PlayerAdapter::getDuration() const
{
    MediaInfo info = m_playerCore->getMediaInfo();
    return info.duration;
}

double PlayerAdapter::getPlaybackSpeed() const
{
    return m_playerCore->getPlaybackSpeed();
}

void PlayerAdapter::setVolume(double volume)
{
    m_playerCore->setVolume(volume);
    
    if (std::abs(m_lastVolume - volume) > 0.001) {
        m_lastVolume = volume;
        emit volumeChanged(volume);
    }
}

double PlayerAdapter::getVolume() const
{
    return m_playerCore->getVolume();
}

void PlayerAdapter::setMuted(bool muted)
{
    if (m_muted != muted) {
        m_muted = muted;
        
        // 如果静音，设置音量为0；否则恢复之前的音量
        if (muted) {
            m_playerCore->setVolume(0.0);
        } else {
            m_playerCore->setVolume(m_lastVolume);
        }
        
        emit mutedChanged(muted);
    }
}

bool PlayerAdapter::isMuted() const
{
    return m_muted;
}

MediaInfo PlayerAdapter::getMediaInfo() const
{
    return m_playerCore->getMediaInfo();
}

PlaybackStats PlayerAdapter::getStats() const
{
    return m_playerCore->getStats();
}

AVFrame* PlayerAdapter::getNextVideoFrame()
{
    return m_playerCore->getNextVideoFrame();
}

AVFrame* PlayerAdapter::getNextAudioFrame()
{
    return m_playerCore->getNextAudioFrame();
}

void PlayerAdapter::releaseVideoFrame(AVFrame* frame)
{
    m_playerCore->releaseVideoFrame(frame);
}

void PlayerAdapter::releaseAudioFrame(AVFrame* frame)
{
    m_playerCore->releaseAudioFrame(frame);
}

void PlayerAdapter::startUpdateTimer(int intervalMs)
{
    if (!m_updateTimer->isActive()) {
        m_updateTimer->start(intervalMs);
        qDebug() << "Update timer started with interval:" << intervalMs << "ms";
    }
}

void PlayerAdapter::stopUpdateTimer()
{
    if (m_updateTimer->isActive()) {
        m_updateTimer->stop();
        qDebug() << "Update timer stopped";
    }
}

void PlayerAdapter::updatePlayer()
{
    // 更新播放器核心
    m_playerCore->update();
    
    // 检查状态变化
    PlayerState currentState = m_playerCore->getState();
    if (currentState != m_lastState) {
        m_lastState = currentState;
        emit stateChanged(currentState);
    }
    
    // 检查位置和时长变化
    checkPositionChanged();
    checkDurationChanged();
    
    // 发送统计信息更新
    PlaybackStats stats = m_playerCore->getStats();
    emit statsUpdated(stats);
    
    // 检查是否有新的视频帧
    if (m_playerCore->getNextVideoFrame() != nullptr) {
        emit videoFrameAvailable();
    }
    
    // 检查是否有新的音频帧
    if (m_playerCore->getNextAudioFrame() != nullptr) {
        emit audioFrameAvailable();
    }
}

void PlayerAdapter::onStateChanged(PlayerState state)
{
    // 在主线程中发送信号
    QMetaObject::invokeMethod(this, [this, state]() {
        if (state != m_lastState) {
            m_lastState = state;
            emit stateChanged(state);
        }
    }, Qt::QueuedConnection);
}

void PlayerAdapter::onMediaInfoChanged(const MediaInfo& info)
{
    // 在主线程中发送信号
    QMetaObject::invokeMethod(this, [this, info]() {
        emit mediaInfoChanged(info);
        
        // 检查时长变化
        if (info.duration != m_lastDuration) {
            m_lastDuration = info.duration;
            emit durationChanged(info.duration);
        }
    }, Qt::QueuedConnection);
}

void PlayerAdapter::onPositionChanged(int64_t position)
{
    // 在主线程中发送信号
    QMetaObject::invokeMethod(this, [this, position]() {
        if (std::abs(position - m_lastPosition) > 100000) { // 100ms阈值(微秒)
            m_lastPosition = position;
            emit positionChanged(position);
        }
    }, Qt::QueuedConnection);
}

void PlayerAdapter::onErrorOccurred(const std::string& error)
{
    QString qError = toQString(error);
    
    // 在主线程中发送信号
    QMetaObject::invokeMethod(this, [this, qError]() {
        emit errorOccurred(qError);
    }, Qt::QueuedConnection);
}

void PlayerAdapter::onEndOfFile()
{
    // 在主线程中发送信号
    QMetaObject::invokeMethod(this, [this]() {
        emit playbackFinished();
        stopUpdateTimer();
    }, Qt::QueuedConnection);
}

void PlayerAdapter::checkPositionChanged()
{
    qint64 currentPosition = getCurrentTime();
    if (std::abs(currentPosition - m_lastPosition) > 100) { // 100ms阈值
        m_lastPosition = currentPosition;
        emit positionChanged(currentPosition);
    }
}

void PlayerAdapter::checkDurationChanged()
{
    qint64 currentDuration = getDuration();
    if (currentDuration != m_lastDuration) {
        m_lastDuration = currentDuration;
        emit durationChanged(currentDuration);
    }
}

QString PlayerAdapter::toQString(const std::string& str) const
{
    return QString::fromStdString(str);
}

void PlayerAdapter::updateRendererType()
{
    QString newType = "None";
    
    if (m_openGLVideoRenderer) {
        newType = "OpenGL";
    } else if (m_videoRenderer) {
        newType = "QLabel";
    }
    
    if (newType != m_currentRendererType) {
        m_currentRendererType = newType;
        emit rendererTypeChanged(newType);
        qDebug() << "Renderer type changed to:" << newType;
    }
}

// PlayerAdapterFactory 实现
std::unique_ptr<PlayerAdapter> PlayerAdapterFactory::create(QObject* parent)
{
    return std::make_unique<PlayerAdapter>(parent);
}

std::shared_ptr<PlayerAdapter> PlayerAdapterFactory::createShared(QObject* parent)
{
    return std::make_shared<PlayerAdapter>(parent);
}

} // namespace player
} // namespace av