video-pc/libs/_AVPlayer2/playercontroller.cpp

#include "playercontroller.h"

#include "common.h"

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

#include "audio_decode_thread.h"
#include "audio_effect_helper.h"
#include "audio_play_thread.h"
#include "ffmpeg_init.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"

Q_LOGGING_CATEGORY(playerControllerLog, "player.controller")

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

    m_state = PlayerState::Idle;
}

PlayerController::~PlayerController()
{
    stopPlay();
}

void PlayerController::startToPlay(const QString& file)
{
    // 使用原子操作和局部变量避免死锁
    PlayerState currentState = m_state.load();
    QString currentFile;
    
    // 快速状态检查，避免不必要的锁竞争
    if (currentState == PlayerState::Initializing) {
        qCDebug(playerControllerLog) << "Player is initializing. Ignoring request.";
        return;
    }

    // 获取当前文件名（需要锁保护）
    {
        std::lock_guard<std::mutex> lock(m_stopMutex);
        currentFile = m_currentFile;
        currentState = m_state.load();
        
        // 自愈：如果状态为Playing但所有线程都已退出，标记需要重置
        if (currentState == PlayerState::Playing && areAllThreadsStopped()) {
            qCDebug(playerControllerLog)
                << "[PlayerController] All threads stopped, will force reset to Idle.";
            // 不在锁内调用stopAndResetThreads，避免死锁
            currentState = PlayerState::Idle; // 标记需要重置
        }
    }

    // 正在播放中，需要先停止
    if (currentState == PlayerState::Playing) {
        qCDebug(playerControllerLog)
            << "Player is busy, stopping and switching to:" << file;
        // 在锁外调用stopPlay，避免死锁
        stopPlay();
        currentState = PlayerState::Idle;
    }

    // 空闲状态，开始新播放
    if (currentState == PlayerState::Idle) {
        // 使用原子操作尝试设置状态
        PlayerState expected = PlayerState::Idle;
        if (!m_state.compare_exchange_strong(expected, PlayerState::Initializing)) {
            qCDebug(playerControllerLog) << "State changed during initialization attempt. Current state:" << (int)expected;
            return;
        }
        
        // 状态已成功设置为Initializing，现在可以安全地进行初始化
        {
            std::lock_guard<std::mutex> lock(m_stopMutex);
            
            // 确保所有线程已停止
            if (!areAllThreadsStopped()) {
                qCDebug(playerControllerLog) << "Some threads still running, stopping them first";
                stopAndResetThreads();
            }

            // 重置状态
            m_videoState.reset();
            m_currentFile = file;
        }

        qCDebug(playerControllerLog) << "Player is idle. Starting playback for:" << file;
        
        // 直接进行初始化，无需异步
        bool success = !file.isEmpty();
        onAsyncInitFinished(file, success);
    }
}



void PlayerController::onAsyncInitFinished(const QString& file, bool success)
{
    // 移除互斥锁，避免与stopPlay产生死锁
    QElapsedTimer timer;
    timer.start();

    // 初始化失败处理
    if (!success) {
        playFailed(m_currentFile);
        m_state = PlayerState::Idle;
        return;
    }

    // 创建视频状态对象
    qCDebug(playerControllerLog) << "[Init] createVideoState...";
    if (!createVideoState(m_currentFile)) {
        qCWarning(playerControllerLog) << "Video state creation failed";
        readPacketStopped();
        playFailed(m_currentFile);
        m_state = PlayerState::Idle;
        return;
    }

    // 检查状态有效性
    assert(m_videoState);
    if (!m_videoState) {
        qCWarning(playerControllerLog) << "Video state initialization error";
        playFailed(m_currentFile);
        m_state = PlayerState::Idle;
        return;
    }

    // 创建数据包读取线程
    qCDebug(playerControllerLog) << "[Init] createReadThread...";
    if (!createReadThread()) {
        qCWarning(playerControllerLog) << "Packet read thread creation failed";
        playFailed(m_currentFile);
        m_state = PlayerState::Idle;
        return;
    }

    // 设置视频状态
    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()) {
            qCWarning(playerControllerLog) << "Video processing setup failed";
            playFailed(m_currentFile);
            stopPlay();
            m_state = PlayerState::Idle;
            return;
        }
    }

    // 创建音频相关线程
    if (hasAudio) {
        if (!createDecodeAudioThread() || !createAudioPlayThread()) {
            qCWarning(playerControllerLog) << "Audio processing setup failed";
            playFailed(m_currentFile);
            stopPlay();
            m_state = PlayerState::Idle;
            return;
        }
    }

    // 创建字幕线程
    if (hasSubtitle && !createDecodeSubtitleThread()) {
        qCWarning(playerControllerLog) << "Subtitle processing setup failed";
        playFailed(m_currentFile);
        stopPlay();
        m_state = PlayerState::Idle;
        return;
    }

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

    emit startToPlaySignal();
    m_state = PlayerState::Playing;

    qCDebug(playerControllerLog) << "Playback initialized in " << timer.elapsed() << " ms";
}

void PlayerController::stopPlay()
{
    // 使用原子操作检查状态，避免不必要的操作
    if (m_state.load() == PlayerState::Idle)
        return;

    qCDebug(playerControllerLog) << "Stopping playback...";
    m_state = PlayerState::Stopping;

    // 停止并重置所有线程
    stopAndResetThreads();

    // 清理视频状态
    {
        std::lock_guard<std::mutex> lock(m_stopMutex);
        m_videoState.reset();
        m_currentFile.clear();
    }
    
    m_state = PlayerState::Idle;
    qCDebug(playerControllerLog) << "Playback stopped.";
}

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()
{
    pausePlay();
}

void PlayerController::playSeekPre()
{
    videoSeekInc(-0.5); // 将步长从2秒减小到0.5秒，提高精度
}

void PlayerController::playSeekNext()
{
    videoSeekInc(0.5); // 将步长从2秒减小到0.5秒，提高精度
}

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
{
    // 使用原子操作获取状态，避免竞态条件
    PlayerState currentState = m_state.load();
    
    // 不仅检查状态标志，还检查线程是否实际运行
    if (currentState != PlayerState::Playing) {
        return false;
    }

    // 如果状态是Playing但所有线程都已停止，则实际上不是在播放状态
    // 使用锁保护线程状态检查，确保一致性
    std::lock_guard<std::mutex> lock(m_stopMutex);
    if (areAllThreadsStopped()) {
        qCDebug(playerControllerLog) << "[isPlaying] State is Playing but all threads stopped";
        return false;
    }

    return true;
}

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) {
        qCWarning(playerControllerLog) << "Audio device initialization failed!";
        return;
    }

    allThreadStart();
    setThreads();
}

void PlayerController::playFailed(const QString& file)
{
    dump();
    qCWarning(playerControllerLog) << "Playback failed for file:" << toNativePath(file);

    // 确保状态一致性
    if (m_state != PlayerState::Idle) {
        // 检查线程状态并重置
        if (!areAllThreadsStopped()) {
            qCDebug(playerControllerLog) << "Some threads still running, stopping them first";
            stopAndResetThreads();
        }
    }

    emit showMessage(QString("Playback failed: %1").arg(toNativePath(file)), "Warning", "");
}

// 线程 finished 槽函数只做日志和信号
void PlayerController::readPacketStopped()
{
    dump();
    qCDebug(playerControllerLog) << "************* Read packets thread stopped signal received.";

    // 不在这里调用delete_video_state，避免与stopAndResetThreads中的调用重复
    // 资源清理统一由stopAndResetThreads处理
    
    emit audioStopped();
}

void PlayerController::decodeVideoStopped()
{
    dump();
    qCDebug(playerControllerLog) << "************* Video decode thread stopped.";
}

void PlayerController::decodeAudioStopped()
{
    dump();
    qCDebug(playerControllerLog) << "************* Audio decode thread stopped.";
}

void PlayerController::decodeSubtitleStopped()
{
    dump();
    qCDebug(playerControllerLog) << "************* Subtitle decode thread stopped.";
}

void PlayerController::audioPlayStopped()
{
    dump();
    qCDebug(playerControllerLog) << "************* Audio play thread stopped.";
    emit audioStopped();
}

void PlayerController::videoPlayStopped()
{
    dump();
    qCDebug(playerControllerLog) << "************* 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);
    }

    // 增强的边界检查：防止seek到超出视频时长的位置
    double max_position = 0.0;
    double min_position = 0.0;
    
    // 安全地计算最大位置
    if (state->ic->duration > 0) {
        max_position = state->ic->duration / static_cast<double>(AV_TIME_BASE);
        if (state->ic->start_time != AV_NOPTS_VALUE && state->ic->start_time > 0) {
            min_position = state->ic->start_time / static_cast<double>(AV_TIME_BASE);
            max_position += min_position;
        }
    } else {
        qCWarning(playerControllerLog) << "[videoSeek] Invalid duration, seek operation cancelled";
        return;
    }

    qCDebug(playerControllerLog) << "[videoSeek] 边界检查: position=" << position 
                                 << ", min_position=" << min_position
                                 << ", max_position=" << max_position
                                 << ", duration=" << state->ic->duration 
                                 << ", start_time=" << state->ic->start_time;

    // 更严格的边界检查：减去5秒作为安全边界，并确保不小于最小位置
    double safe_boundary = 5.0;
    if (position < min_position) {
        qCDebug(playerControllerLog) << "[videoSeek] 调整seek位置到最小值: 原始position=" << position;
        position = min_position;
    } else if (position > max_position - safe_boundary) {
        qCDebug(playerControllerLog) << "[videoSeek] 调整seek位置到安全范围: 原始position=" << position
                                     << ", 最大position=" << max_position;
        position = std::max(min_position, max_position - safe_boundary);
    }
    
    qCDebug(playerControllerLog) << "[videoSeek] 最终position=" << position;

    // 添加量化操作，精确到0.01秒
    qCDebug(playerControllerLog) << "[videoSeek] position:" << position
                                 << "position * AV_TIME_BASE:" << static_cast<int64_t>(position * AV_TIME_BASE)
                                 << "increment * AV_TIME_BASE:" << static_cast<int64_t>(increment * AV_TIME_BASE);

    // 启用精确帧定位
    int64_t target_pts = static_cast<int64_t>(position * AV_TIME_BASE);
    // if (state->video_st) {
    //     // 将目标时间转换为视频流的时间基准
    //     target_pts = av_rescale_q(target_pts,
    //                               AV_TIME_BASE_Q,
    //                               state->video_st->time_base);
    //     qDebug() << "[精确帧定位] 设置目标PTS:" << target_pts
    //              << "原始位置(秒):" << position
    //              << "视频时间基准:" << state->video_st->time_base.num << "/" << state->video_st->time_base.den;
    //     state->exact_seek = 1;
    //     state->target_pts = target_pts;
    // }

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

void PlayerController::videoSeekEx(double value, double maxValue)
{
    if (!m_videoState)
        return;

    auto state = m_videoState->get_state();
    if (!state)
        return;
    auto cur_stream = state;
    auto x = value;
    double frac;

    if (m_videoState->seekByBytes() || cur_stream->ic->duration <= 0) {
        uint64_t size = avio_size(cur_stream->ic->pb);
        stream_seek(cur_stream, size * x / maxValue, 0, 1);
    } else {
        int64_t ts;
        int ns, hh, mm, ss;
        int tns, thh, tmm, tss;
        tns = cur_stream->ic->duration / 1000000LL;
        thh = tns / 3600;
        tmm = (tns % 3600) / 60;
        tss = (tns % 60);
        frac = x / maxValue;
        ns = frac * tns;
        hh = ns / 3600;
        mm = (ns % 3600) / 60;
        ss = (ns % 60);
        av_log(NULL,
               AV_LOG_INFO,
               "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d)       \n",
               frac * 100,
               hh,
               mm,
               ss,
               thh,
               tmm,
               tss);
        qDebug("Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d)",
               frac * 100,
               hh,
               mm,
               ss,
               thh,
               tmm,
               tss);
        ts = frac * cur_stream->ic->duration;
        if (cur_stream->ic->start_time != AV_NOPTS_VALUE)
            ts += cur_stream->ic->start_time;

        // 增强的边界检查：防止seek到超出视频时长的位置
        int64_t max_ts = 0;
        int64_t min_ts = 0;
        
        // 安全地计算时间戳边界
        if (cur_stream->ic->duration > 0) {
            max_ts = cur_stream->ic->duration;
            if (cur_stream->ic->start_time != AV_NOPTS_VALUE && cur_stream->ic->start_time > 0) {
                min_ts = cur_stream->ic->start_time;
                max_ts += min_ts;
            }
        } else {
            qCWarning(playerControllerLog) << "[videoSeekEx] Invalid duration, seek operation cancelled";
            return;
        }

        qCDebug(playerControllerLog) << "[videoSeekEx] 边界检查: ts=" << ts 
                                     << ", min_ts=" << min_ts << ", max_ts=" << max_ts
                                     << ", duration=" << cur_stream->ic->duration
                                     << ", start_time=" << cur_stream->ic->start_time
                                     << ", 请求位置(秒)=" << ts / (double) AV_TIME_BASE
                                     << ", 最大位置(秒)=" << max_ts / (double) AV_TIME_BASE;

        // 更严格的边界检查：减去5秒作为安全边界
        int64_t safe_boundary = 5 * AV_TIME_BASE;
        if (ts < min_ts) {
            qCDebug(playerControllerLog) << "[videoSeekEx] 调整seek位置到最小值: 原始ts=" << ts;
            ts = min_ts;
        } else if (ts > max_ts - safe_boundary) {
            qCDebug(playerControllerLog) << "[videoSeekEx] 调整seek位置到安全范围: 原始ts=" << ts << ", 最大ts=" << max_ts;
            ts = std::max(min_ts, max_ts - safe_boundary);
        }
        
        qCDebug(playerControllerLog) << "[videoSeekEx] 最终ts=" << ts
                                     << ", 最终位置(秒)=" << ts / (double) AV_TIME_BASE;

        // // 启用精确帧定位
        // if (cur_stream->video_st) {
        //     int64_t target_pts = av_rescale_q(ts,
        //                                       AV_TIME_BASE_Q,
        //                                       cur_stream->video_st->time_base);
        //     qDebug() << "[精确帧定位Ex] 设置目标PTS:" << target_pts
        //              << "原始位置(秒):" << ts / (double)AV_TIME_BASE
        //              << "视频时间基准:" << cur_stream->video_st->time_base.num << "/" << cur_stream->video_st->time_base.den;
        //     state->exact_seek = 1;
        //     state->target_pts = target_pts;
        // }

        stream_seek(cur_stream, ts, 0, 0);
    }
    return;
}

// 线程管理辅助方法
void PlayerController::stopAndResetThreads()
{
    qDebug() << "++++++++++ stopAndResetThreads";
    auto stopAndReset = [](auto& threadPtr, const QString& threadName) {
        if (threadPtr) {
            qCDebug(playerControllerLog)
                << "[stopAndReset] [" << threadName
                << "] try stop/join thread, isRunning=" << threadPtr->isRunning();
            threadPtr->stop();

            // 增加超时等待时间，以便更好地处理FFmpeg清理
            const int MAX_WAIT_MS = 3000; // 增加到3秒，给FFmpeg足够的清理时间
            auto startTime = std::chrono::steady_clock::now();

            while (threadPtr->isRunning()) {
                auto now = std::chrono::steady_clock::now();
                auto elapsed
                    = std::chrono::duration_cast<std::chrono::milliseconds>(now - startTime).count();
                if (elapsed > MAX_WAIT_MS) {
                    qCWarning(playerControllerLog)
                        << "[stopAndReset] [" << threadName << "] Thread stop timeout after"
                        << elapsed << "ms - forcing termination";
                    break;
                }
                // 减少轮询频率，降低CPU占用
                std::this_thread::sleep_for(std::chrono::milliseconds(50));
            }
            // 只有线程已停止才join
            if (!threadPtr->isRunning()) {
                threadPtr->join();
                qCDebug(playerControllerLog)
                    << "[stopAndReset] [" << threadName << "] thread joined and will reset.";
            }
            threadPtr.reset();
        }
    };

    // 优化线程停止顺序：先停止播放线程，然后清理FFmpeg状态，再停止解码线程，最后停止读取线程
    // 这样确保解码线程在FFmpeg资源清理后能正常退出
    
    // 第一阶段：停止播放线程
    stopAndReset(m_beforePlayThread, "BeforePlay");
    stopAndReset(m_videoPlayThread, "VideoPlay");
    stopAndReset(m_audioPlayThread, "AudioPlay");
    
    // 第二阶段：清理FFmpeg状态（关键修复：在解码线程停止前清理）
    // 这样解码线程就能检测到状态变化并正常退出
    if (m_videoState && m_videoState->get_state()) {
        qCDebug(playerControllerLog) << "[stopAndResetThreads] Cleaning up FFmpeg video state before stopping decode threads";
        m_videoState->delete_video_state();
        
        // 给解码线程一点时间检测到FFmpeg状态变化
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        qCDebug(playerControllerLog) << "[stopAndResetThreads] FFmpeg state cleaned, proceeding to stop decode threads";
    }
    
    // 第三阶段：停止解码线程（现在FFmpeg状态已清理，线程应该能正常退出）
    stopAndReset(m_decodeVideoThread, "DecodeVideo");
    stopAndReset(m_decodeAudioThread, "DecodeAudio");
    stopAndReset(m_decodeSubtitleThread, "DecodeSubtitle");
    
    // 第四阶段：停止读取线程
    stopAndReset(m_packetReadThread, "PacketRead");
}

bool PlayerController::areAllThreadsStopped() const
{
    // 检查所有线程是否已停止
    // 注意：此方法应在持有m_stopMutex锁的情况下调用，以确保线程状态的一致性
    bool allStopped = (!m_packetReadThread || !m_packetReadThread->isRunning())
                      && (!m_decodeVideoThread || !m_decodeVideoThread->isRunning())
                      && (!m_decodeAudioThread || !m_decodeAudioThread->isRunning())
                      && (!m_audioPlayThread || !m_audioPlayThread->isRunning())
                      && (!m_videoPlayThread || !m_videoPlayThread->isRunning())
                      && (!m_decodeSubtitleThread || !m_decodeSubtitleThread->isRunning())
                      && (!m_beforePlayThread || !m_beforePlayThread->isRunning());
    
    return allStopped;
}

void PlayerController::allThreadStart()
{
    // 启动所有创建的线程
    if (m_packetReadThread) {
        if (!m_videoState || !m_videoState->get_state()) {
            qCWarning(playerControllerLog) << "VideoState invalid, skip starting read thread";
        } else {
            m_packetReadThread->start();
        }
        qCDebug(playerControllerLog) << "++++++++++ Read packets thread started";
    }

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

    if (m_decodeAudioThread) {
        m_decodeAudioThread->start();
        qCDebug(playerControllerLog) << "++++++++++ Audio decode thread started";
    }

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

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

    if (m_audioPlayThread) {
        m_audioPlayThread->start();
        qCDebug(playerControllerLog) << "++++++++++ 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();
        qCWarning(playerControllerLog) << "Video state creation failed (error: " << ret << ")";
        return false;
    }

    return true;
}

bool PlayerController::createReadThread()
{
    if (m_packetReadThread)
        return false;
    m_packetReadThread = std::make_unique<ReadThread>(m_videoState ? m_videoState->get_state()
                                                                   : nullptr);
    m_packetReadThread->setOnFinished([this]() { 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>(state);
    m_decodeVideoThread->setOnFinished([this]() { 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) {
        qCWarning(playerControllerLog)
            << "Video decoder initialization failed (error: " << ret << ")";
        return false;
    }

    ret = decoder_start(&state->viddec, m_decodeVideoThread.get(), "video_decoder");
    if (ret < 0) {
        qCWarning(playerControllerLog) << "Video decoder start failed (error: " << 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>(state);
    m_decodeAudioThread->setOnFinished([this]() { 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) {
        qCWarning(playerControllerLog)
            << "Audio decoder initialization failed (error: " << ret << ")";
        return false;
    }

    ret = decoder_start(&state->auddec, m_decodeAudioThread.get(), "audio_decoder");
    if (ret < 0) {
        qCWarning(playerControllerLog) << "Audio decoder start failed (error: " << 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>(state);
    m_decodeSubtitleThread->setOnFinished([this]() { 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) {
        qCWarning(playerControllerLog)
            << "Subtitle decoder initialization failed (error: " << ret << ")";
        return false;
    }

    ret = decoder_start(&state->subdec, m_decodeSubtitleThread.get(), "subtitle_decoder");
    if (ret < 0) {
        qCWarning(playerControllerLog) << "Subtitle decoder start failed (error: " << 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>(state);
    m_videoPlayThread->setOnFinished([this]() { videoPlayStopped(); });
    m_videoPlayThread->setOnFrameReady([this](AVFrame* frame) { this->onFrameReady(frame); });
    m_videoPlayThread->setOnSubtitleReady([](const QString& text) {
        // onSubtitleReady(text);
    });

    // 初始化参数
    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)) {
        qCWarning(playerControllerLog) << "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>(state);
    m_audioPlayThread->setOnFinished([this]() { audioPlayStopped(); });
    m_audioPlayThread->setOnUpdatePlayTime([this]() {
        // TODO: 实现 PlayerController::onUpdatePlayTime() 处理播放时间更新
        emit updatePlayTime();
    });
    m_audioPlayThread->setOnDataVisualReady([this](const AudioData& data) {
        // 异步 ?
        emit audioData(data);
    });

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

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

    m_beforePlayThread = std::make_unique<StartPlayThread>(m_audioPlayThread.get(),
                                                           m_videoState.get());

    m_beforePlayThread->setOnFinished([this]() {
        qCDebug(playerControllerLog) << "[StartPlayThread] finished, call playStarted()";
        playStarted();
    });
    m_beforePlayThread->start();
    qCDebug(playerControllerLog) << "++++++++++ StartPlay thread (audio init) started";

    return true;
}

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

    qCInfo(playerControllerLog) << (isVideo ? "Video" : "Audio")
                                << " codec: " << codecCtx->codec->name;
    qCInfo(playerControllerLog) << "  Type:" << codecCtx->codec_type << "ID:" << codecCtx->codec_id
                                << "Tag:" << codecCtx->codec_tag;

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

// 在合适位置实现 onFrameReady
void PlayerController::onFrameReady(AVFrame* frame)
{
    // 这里可以做帧处理、缓存、同步等操作
    emit frameReady(frame); // 直接转发给 UI 层
}

void PlayerController::dump() const
{
    qCInfo(playerControllerLog) << "=== PlayerController Thread Status Dump ===";
    qCInfo(playerControllerLog) << "Current State:" << static_cast<int>(m_state.load());
    qCInfo(playerControllerLog) << "Current File:" << m_currentFile;

    // 检查数据包读取线程
    if (m_packetReadThread) {
        qCInfo(playerControllerLog)
            << "ReadThread: exists, isRunning:" << m_packetReadThread->isRunning()
            << ", isFinished:" << m_packetReadThread->isExit();
    } else {
        qCInfo(playerControllerLog) << "ReadThread: null";
    }

    // 检查视频解码线程
    if (m_decodeVideoThread) {
        qCInfo(playerControllerLog)
            << "VideoDecodeThread: exists, isRunning:" << m_decodeVideoThread->isRunning()
            << ", isFinished:" << m_decodeVideoThread->isExit();
    } else {
        qCInfo(playerControllerLog) << "VideoDecodeThread: null";
    }

    // 检查音频解码线程
    if (m_decodeAudioThread) {
        qCInfo(playerControllerLog)
            << "AudioDecodeThread: exists, isRunning:" << m_decodeAudioThread->isRunning()
            << ", isFinished:" << m_decodeAudioThread->isExit();
    } else {
        qCInfo(playerControllerLog) << "AudioDecodeThread: null";
    }

    // 检查字幕解码线程
    if (m_decodeSubtitleThread) {
        qCInfo(playerControllerLog)
            << "SubtitleDecodeThread: exists, isRunning:" << m_decodeSubtitleThread->isRunning()
            << ", isFinished:" << m_decodeSubtitleThread->isExit();
    } else {
        qCInfo(playerControllerLog) << "SubtitleDecodeThread: null";
    }

    // 检查音频播放线程
    if (m_audioPlayThread) {
        qCInfo(playerControllerLog)
            << "AudioPlayThread: exists, isRunning:" << m_audioPlayThread->isRunning()
            << ", isFinished:" << m_audioPlayThread->isExit();
    } else {
        qCInfo(playerControllerLog) << "AudioPlayThread: null";
    }

    // 检查视频播放线程
    if (m_videoPlayThread) {
        qCInfo(playerControllerLog)
            << "VideoPlayThread: exists, isRunning:" << m_videoPlayThread->isRunning()
            << ", isFinished:" << m_videoPlayThread->isExit();
    } else {
        qCInfo(playerControllerLog) << "VideoPlayThread: null";
    }

    // 检查播放前准备线程
    if (m_beforePlayThread) {
        qCInfo(playerControllerLog)
            << "StartPlayThread: exists, isRunning:" << m_beforePlayThread->isRunning()
            << ", isFinished:" << m_beforePlayThread->isExit();
    } else {
        qCInfo(playerControllerLog) << "StartPlayThread: null";
    }

    // 检查事件线程
    if (m_eventThread.joinable()) {
        qCInfo(playerControllerLog) << "EventThread: joinable (running)";
    } else {
        qCInfo(playerControllerLog) << "EventThread: not joinable (stopped or not started)";
    }

    qCInfo(playerControllerLog) << "=== End of Thread Status Dump ===";
}