video-pc/AvPlayer2/playercontroller.cpp

#include "playercontroller.h"

#include "common.h"

#include <QApplication>
#include <QElapsedTimer>
#include <QStatusBar>
#include <cassert>
#include <memory>

#include "ffmpeg_init.h"
#include "start_play_thread.h"
#include "video_state.h"

#include "audio_decode_thread.h"
#include "audio_effect_helper.h"
#include "audio_play_thread.h"
#include "play_control_window.h"
#include "read_thread.h"
#include "start_play_thread.h"
#include "stopplay_waiting_thread.h"
#include "subtitle_decode_thread.h"
#include "video_decode_thread.h"
#include "video_play_thread.h"
#include "video_state.h"

PlayerController::PlayerController(QWidget* parent)
    : QObject(parent)
{
    ffmpeg_init();
}

PlayerController::~PlayerController()
{
    // 等待初始化线程安全退出
    if (m_initThread.joinable()) {
        {
            std::lock_guard<std::mutex> lock(m_initMutex);
            m_initInProgress = false;
        }
        m_initCv.notify_all();
        m_initThread.join();
    }
    stopPlay();
}

// 播放控制接口
void PlayerController::startToPlay(const QString& file)
{
    if (isPlaying()) {
        if (m_currentFile == file)
            return;
        waitStopPlay(file);
        return;
    }
    m_currentFile = file;
    if (m_initInProgress) return; // 正在初始化，直接返回
    m_initInProgress = true;
    if (m_initThread.joinable()) m_initThread.join();
    m_initThread = std::thread(&PlayerController::asyncInit, this, file);
}

void PlayerController::asyncInit(const QString& file)
{
    bool success = false;
    // startPlay 的主体迁移到这里
    QElapsedTimer timer;
    timer.start();
    if (file.isEmpty()) {
        qWarning("Filename is invalid. Please select a valid media file.");
        success = false;
    } else {
        qInfo("Starting playback: %s", qUtf8Printable(toNativePath(file)));
        if (!createReadThread()) {
            qWarning("Packet read thread creation failed");
            success = false;
        } else if (!createVideoState(file)) {
            qWarning("Video state creation failed");
            readPacketStopped();
            success = false;
        } else if (!m_videoState) {
            qWarning("Video state initialization error");
            success = false;
        } else {
            m_packetReadThread->set_video_state(m_videoState->get_state());
            const bool hasVideo = playingHasVideo();
            const bool hasAudio = playingHasAudio();
            const bool hasSubtitle = playingHasSubtitle();
            if (hasVideo) {
                if (!createDecodeVideoThread() || !createVideoPlayThread()) {
                    qWarning("Video processing setup failed");
                    success = false;
                }
            }
            if (hasAudio) {
                if (!createDecodeAudioThread() || !createAudioPlayThread()) {
                    qWarning("Audio processing setup failed");
                    success = false;
                }
            }
            if (hasSubtitle && !createDecodeSubtitleThread()) {
                qWarning("Subtitle processing setup failed");
                success = false;
            }
            // 开始播放
            if (hasAudio) {
                // 音频设备初始化在独立线程中完成
                startPlayThread();
            } else {
                playStarted();
            }
            success = true;
        }
    }
    {
        std::lock_guard<std::mutex> lock(m_initMutex);
        m_initSuccess = success;
        m_initInProgress = false;
    }
    m_initCv.notify_all();
    onInitFinished(success);
    qDebug("Playback initialized in %lld ms", timer.elapsed());
}

void PlayerController::onInitFinished(bool success)
{
    // 这里可以发 Qt 信号或回调
    if (!success) {
        playFailed(m_currentFile);
        return;
    }
    emit startToPlaySignal();
}

void PlayerController::stopPlay()
{
    deleteVideoState();
    m_packetReadThread.reset();
    m_decodeVideoThread.reset();
    m_decodeAudioThread.reset();
    m_decodeSubtitleThread.reset();
    m_videoPlayThread.reset();
    m_audioPlayThread.reset();
}

void PlayerController::pausePlay()
{
    if (!m_videoState)
        return;

    if (auto state = m_videoState->get_state())
        toggle_pause(state, !state->paused);

    emit updatePlayControlStatus();
}

void PlayerController::playMute(bool mute)
{
    if (!m_videoState)
        return;

    if (auto state = m_videoState->get_state())
        toggle_mute(state, mute);
}

void PlayerController::playStartSeek()
{
    emit playSeek();
    pausePlay();
}

void PlayerController::playSeekPre()
{
    videoSeekInc(-2);
}

void PlayerController::playSeekNext()
{
    videoSeekInc(2);
}

void PlayerController::setVolume(int volume, int maxValue)
{
    if (!m_audioPlayThread)
        return;

    const float vol = static_cast<float>(volume) / maxValue;
    m_audioPlayThread->set_device_volume(vol);
}

void PlayerController::setPlaySpeed(double speed)
{
    if (m_videoState) {
        if (auto state = m_videoState->get_state()) {
#if USE_AVFILTER_AUDIO
            set_audio_playspeed(state, speed);
#endif
        }
    }
}

// 状态访问接口
QString PlayerController::playingFile() const
{
    return isPlaying() ? m_currentFile : QString();
}

bool PlayerController::isPlaying() const
{
    return m_videoState || m_packetReadThread || m_decodeVideoThread || m_decodeAudioThread
           || m_audioPlayThread || m_videoPlayThread || m_decodeSubtitleThread;
}

bool PlayerController::playingHasVideo()
{
    return m_videoState ? m_videoState->has_video() : false;
}

bool PlayerController::playingHasAudio()
{
    return m_videoState ? m_videoState->has_audio() : false;
}

bool PlayerController::playingHasSubtitle()
{
    return m_videoState ? m_videoState->has_subtitle() : false;
}

VideoState* PlayerController::state()
{
    return m_videoState ? m_videoState->get_state() : nullptr;
}

float PlayerController::deviceVolume() const
{
    return m_audioPlayThread ? m_audioPlayThread->get_device_volume() : 0.0f;
}

void PlayerController::setDeviceVolume(float volume)
{
    if (m_audioPlayThread)
        m_audioPlayThread->set_device_volume(volume);
}

// 播放状态回调槽函数
void PlayerController::playStarted(bool success)
{
    if (!success) {
        qWarning("Audio device initialization failed!");
        return;
    }

    allThreadStart();
    setThreads();
}

void PlayerController::playFailed(const QString& file)
{
    emit showMessage(QString("Playback failed: %1").arg(toNativePath(file)), "Warning", "");
}

// 线程生命周期管理槽函数
void PlayerController::readPacketStopped()
{
    if (m_packetReadThread) {
        m_packetReadThread.reset();
        qDebug("************* Read packets thread stopped.");
    }

    stopPlay();
}

void PlayerController::decodeVideoStopped()
{
    m_decodeVideoThread.reset();
    qDebug("************* Video decode thread stopped.");
}

void PlayerController::decodeAudioStopped()
{
    m_decodeAudioThread.reset();
    qDebug("************* Audio decode thread stopped.");
}

void PlayerController::decodeSubtitleStopped()
{
    m_decodeSubtitleThread.reset();
    qDebug("************* Subtitle decode thread stopped.");
}

void PlayerController::audioPlayStopped()
{
    m_audioPlayThread.reset();
    qDebug("************* Audio play thread stopped.");
    emit audioStopped(); // 音频结束
}

void PlayerController::videoPlayStopped()
{
    m_videoPlayThread.reset();
    qDebug("************* Video play thread stopped.");

    emit videoStopped(); // 视频结束
}

// 线程管理槽函数
void PlayerController::setThreads()
{
    if (!m_videoState)
        return;

    Threads threads;
    threads.read_tid = m_packetReadThread.get();
    threads.video_decode_tid = m_decodeVideoThread.get();
    threads.audio_decode_tid = m_decodeAudioThread.get();
    threads.video_play_tid = m_videoPlayThread.get();
    threads.audio_play_tid = m_audioPlayThread.get();
    threads.subtitle_decode_tid = m_decodeSubtitleThread.get();

    m_videoState->threads_setting(m_videoState->get_state(), threads);
}

void PlayerController::startSendData(bool send)
{
    if (m_audioPlayThread)
        m_audioPlayThread->send_visual_open(send);
}

void PlayerController::videoSeek(double position, double increment)
{
    if (!m_videoState)
        return;

    auto state = m_videoState->get_state();
    if (!state)
        return;

    if (state->ic->start_time != AV_NOPTS_VALUE
        && position < state->ic->start_time / static_cast<double>(AV_TIME_BASE)) {
        position = state->ic->start_time / static_cast<double>(AV_TIME_BASE);
    }

    stream_seek(state,
                static_cast<int64_t>(position * AV_TIME_BASE),
                static_cast<int64_t>(increment * AV_TIME_BASE),
                0);
}

// 核心私有实现
bool PlayerController::startPlay()
{
    QElapsedTimer timer;
    timer.start();

    if (m_currentFile.isEmpty()) {
        qWarning("Filename is invalid. Please select a valid media file.");
        return false;
    }

    qInfo("Starting playback: %s", qUtf8Printable(toNativePath(m_currentFile)));

    // 创建数据包读取线程
    if (!createReadThread()) {
        qWarning("Packet read thread creation failed");
        return false;
    }

    // 创建视频状态对象
    if (!createVideoState(m_currentFile)) {
        qWarning("Video state creation failed");
        readPacketStopped();
        return false;
    }

    // 检查状态有效性
    assert(m_videoState);
    if (!m_videoState) {
        qWarning("Video state initialization error");
        return false;
    }

    m_packetReadThread->set_video_state(m_videoState->get_state());

    const bool hasVideo = playingHasVideo();
    const bool hasAudio = playingHasAudio();
    const bool hasSubtitle = playingHasSubtitle();

    // 创建视频相关线程
    if (hasVideo) {
        if (!createDecodeVideoThread() || !createVideoPlayThread()) {
            qWarning("Video processing setup failed");
            return false;
        }
    }

    // 创建音频相关线程
    if (hasAudio) {
        if (!createDecodeAudioThread() || !createAudioPlayThread()) {
            qWarning("Audio processing setup failed");
            return false;
        }
    }

    // 创建字幕线程
    if (hasSubtitle && !createDecodeSubtitleThread()) {
        qWarning("Subtitle processing setup failed");
        return false;
    }

    // 开始播放
    if (hasAudio) {
        startPlayThread(); // 异步启动（处理音频设备初始化）
    } else {
        playStarted(); // 同步启动（无音频流）
    }

    qDebug("Playback initialized in %lld ms", timer.elapsed());
    return true;
}

void PlayerController::waitStopPlay(const QString& file)
{
    m_stopPlayWaitingThread = std::make_unique<StopWaitingThread>(this, file);
    connect(m_stopPlayWaitingThread.get(),
            &StopWaitingThread::stopPlay,
            this,
            &PlayerController::stopPlay);
    connect(m_stopPlayWaitingThread.get(),
            &StopWaitingThread::startPlay,
            this,
            &PlayerController::startToPlay);

    m_stopPlayWaitingThread->start();
    qDebug("++++++++++ StopPlay waiting thread started");
}

void PlayerController::allThreadStart()
{
    // 启动所有创建的线程
    if (m_packetReadThread) {
        m_packetReadThread->start();
        qDebug("++++++++++ Read packets thread started");
    }

    if (m_decodeVideoThread) {
        m_decodeVideoThread->start();
        qDebug("++++++++++ Video decode thread started");
    }

    if (m_decodeAudioThread) {
        m_decodeAudioThread->start(QThread::Priority::HighPriority);
        qDebug("++++++++++ Audio decode thread started");
    }

    if (m_decodeSubtitleThread) {
        m_decodeSubtitleThread->start();
        qDebug("++++++++++ Subtitle decode thread started");
    }

    if (m_videoPlayThread) {
        m_videoPlayThread->start();
        qDebug("++++++++++ Video play thread started");
    }

    if (m_audioPlayThread) {
        m_audioPlayThread->start();
        qDebug("++++++++++ Audio play thread started");
    }

    // 通知UI更新
    emit setPlayControlWnd(true);
    emit updatePlayControlVolume();
    emit updatePlayControlStatus();
}

// 辅助函数
void PlayerController::videoSeekInc(double increment)
{
    if (!m_videoState)
        return;

    auto state = m_videoState->get_state();
    if (!state)
        return;

    double position = get_master_clock(state);
    if (std::isnan(position)) {
        position = static_cast<double>(state->seek_pos) / AV_TIME_BASE;
    }

    position += increment;
    videoSeek(position, increment);
}

// 线程创建方法
bool PlayerController::createVideoState(const QString& file)
{
    const bool useHardware = false; // 待实现：来自UI设置
    const bool loop = false;        // 待实现：来自UI设置

    if (m_videoState)
        return false;

    m_videoState = std::make_unique<VideoStateData>(useHardware, loop);
    const int ret = m_videoState->create_video_state(file.toUtf8().constData());

    if (ret < 0) {
        m_videoState.reset();
        qWarning("Video state creation failed (error: %d)", ret);
        return false;
    }

    return true;
}

void PlayerController::deleteVideoState()
{
    m_videoState.reset();
}

bool PlayerController::createReadThread()
{
    if (m_packetReadThread)
        return false;

    m_packetReadThread = std::make_unique<ReadThread>(this);
    connect(m_packetReadThread.get(),
            &ReadThread::finished,
            this,
            &PlayerController::readPacketStopped);

    return true;
}

bool PlayerController::createDecodeVideoThread()
{
    if (!m_videoState || m_decodeVideoThread)
        return false;

    auto state = m_videoState->get_state();
    if (!state)
        return false;

    m_decodeVideoThread = std::make_unique<VideoDecodeThread>(this, state);
    connect(m_decodeVideoThread.get(),
            &VideoDecodeThread::finished,
            this,
            &PlayerController::decodeVideoStopped);

    auto codecContext = m_videoState->get_contex(AVMEDIA_TYPE_VIDEO);

    // 初始化视频解码器
    int ret = decoder_init(&state->viddec,
                           codecContext,
                           &state->videoq,
                           state->continue_read_thread);
    if (ret < 0) {
        qWarning("Video decoder initialization failed (error: %d)", ret);
        return false;
    }

    ret = decoder_start(&state->viddec, m_decodeVideoThread.get(), "video_decoder");
    if (ret < 0) {
        qWarning("Video decoder start failed (error: %d)", ret);
        return false;
    }

    state->queue_attachments_req = 1;
    return true;
}

bool PlayerController::createDecodeAudioThread()
{
    if (!m_videoState || m_decodeAudioThread)
        return false;

    auto state = m_videoState->get_state();
    if (!state)
        return false;

    m_decodeAudioThread = std::make_unique<AudioDecodeThread>(this, state);
    connect(m_decodeAudioThread.get(),
            &AudioDecodeThread::finished,
            this,
            &PlayerController::decodeAudioStopped);

    auto codecContext = m_videoState->get_contex(AVMEDIA_TYPE_AUDIO);

    // 初始化音频解码器
    int ret = decoder_init(&state->auddec,
                           codecContext,
                           &state->audioq,
                           state->continue_read_thread);
    if (ret < 0) {
        qWarning("Audio decoder initialization failed (error: %d)", ret);
        return false;
    }

    ret = decoder_start(&state->auddec, m_decodeAudioThread.get(), "audio_decoder");
    if (ret < 0) {
        qWarning("Audio decoder start failed (error: %d)", ret);
        return false;
    }

    return true;
}

bool PlayerController::createDecodeSubtitleThread()
{
    if (!m_videoState || m_decodeSubtitleThread)
        return false;

    auto state = m_videoState->get_state();
    if (!state)
        return false;

    m_decodeSubtitleThread = std::make_unique<SubtitleDecodeThread>(this, state);
    connect(m_decodeSubtitleThread.get(),
            &SubtitleDecodeThread::finished,
            this,
            &PlayerController::decodeSubtitleStopped);

    auto codecContext = m_videoState->get_contex(AVMEDIA_TYPE_SUBTITLE);

    // 初始化字幕解码器
    int ret = decoder_init(&state->subdec,
                           codecContext,
                           &state->subtitleq,
                           state->continue_read_thread);
    if (ret < 0) {
        qWarning("Subtitle decoder initialization failed (error: %d)", ret);
        return false;
    }

    ret = decoder_start(&state->subdec, m_decodeSubtitleThread.get(), "subtitle_decoder");
    if (ret < 0) {
        qWarning("Subtitle decoder start failed (error: %d)", ret);
        return false;
    }

    return true;
}

bool PlayerController::createVideoPlayThread()
{
    if (!m_videoState || m_videoPlayThread)
        return false;

    auto state = m_videoState->get_state();
    if (!state)
        return false;

    m_videoPlayThread = std::make_unique<VideoPlayThread>(this, state);

    // 连接信号
    connect(m_videoPlayThread.get(),
            &VideoPlayThread::finished,
            this,
            &PlayerController::videoPlayStopped);
    connect(m_videoPlayThread.get(),
            &VideoPlayThread::frameReady,
            this,
            &PlayerController::frameReady);
    connect(m_videoPlayThread.get(),
            &VideoPlayThread::subtitle_ready,
            this,
            &PlayerController::subtitleReady);
    connect(this,
            &PlayerController::stopVideoPlayThread,
            m_videoPlayThread.get(),
            &VideoPlayThread::stop_thread);

    // 初始化参数
    auto videoContext = m_videoState->get_contex(AVMEDIA_TYPE_VIDEO);
    const bool useHardware = m_videoState->is_hardware_decode();

    if (!m_videoPlayThread->init_resample_param(videoContext, useHardware)) {
        qWarning("Video resample parameters initialization failed");
        return false;
    }

    return true;
}

bool PlayerController::createAudioPlayThread()
{
    if (!m_videoState || m_audioPlayThread)
        return false;

    auto state = m_videoState->get_state();
    if (!state)
        return false;

    m_audioPlayThread = std::make_unique<AudioPlayThread>(this, state);

    // 连接信号
    connect(m_audioPlayThread.get(),
            &AudioPlayThread::finished,
            this,
            &PlayerController::audioPlayStopped);
    connect(this,
            &PlayerController::stopAudioPlayThread,
            m_audioPlayThread.get(),
            &AudioPlayThread::stop_thread);
    connect(m_audioPlayThread.get(),
            &AudioPlayThread::update_play_time,
            this,
            &PlayerController::updatePlayTime);
    connect(m_audioPlayThread.get(),
            &AudioPlayThread::data_visual_ready,
            this,
            &PlayerController::audioData);

    // 音频设备初始化在独立线程中完成
    return true;
}

bool PlayerController::startPlayThread()
{
    if (m_beforePlayThread)
        return false;

    m_beforePlayThread = std::make_unique<StartPlayThread>(this, this);
    connect(m_beforePlayThread.get(),
            &StartPlayThread::audio_device_init,
            this,
            &PlayerController::playStarted);

    m_beforePlayThread->start();
    qDebug("++++++++++ StartPlay thread (audio init) started");

    return true;
}

// 调试辅助函数
void PlayerController::printDecodeContext(const AVCodecContext* codecCtx, bool isVideo) const
{
    if (!codecCtx)
        return;

    qInfo("%s codec: %s", isVideo ? "Video" : "Audio", codecCtx->codec->name);
    qInfo("  Type: %d, ID: %d, Tag: %d",
          codecCtx->codec_type,
          codecCtx->codec_id,
          codecCtx->codec_tag);

    if (isVideo) {
        qInfo("  Dimensions: %dx%d", codecCtx->width, codecCtx->height);
    } else {
        qInfo("  Sample rate: %d Hz, Channels: %d, Format: %d",
              codecCtx->sample_rate,
              codecCtx->ch_layout.nb_channels,
              codecCtx->sample_fmt);
        qInfo("  Frame size: %d, Block align: %d", codecCtx->frame_size, codecCtx->block_align);
    }
}