vlckits.cpp

#include "vlckits.h"

VLCkits::VLCkits(QObject *parent) : QObject(parent)
{
    const char* vlc_args[] = {
        //"--no-plugins-cache",
        "--ignore-config",
        "--quiet",
        "--no-video-title-show",
        //"--avcodec-hw=any"
    };

    _pinstance = libvlc_new(sizeof(vlc_args)/sizeof(vlc_args[0]),vlc_args);
    if (!_pinstance) {
        qDebug() << " 无法创建 libVLC 实例！";
//        return;
    }

    _pTimer = new QTimer(this);
    _pTimer->setInterval(50); // 每 50ms 更新一次（足够平滑）
    connect(_pTimer, &QTimer::timeout, this, &VLCkits::onTimerUpdate);
    _pTimer->start();

}

VLCkits::~VLCkits() {
    if (_pmediaPlayer) {
        libvlc_media_player_stop(_pmediaPlayer);
        libvlc_media_player_release(_pmediaPlayer);
        _pmediaPlayer = nullptr;
    }
    if (_pmedia) {
        libvlc_media_release(_pmedia);
        _pmedia = nullptr;
    }
    if (_pinstance) {
        libvlc_release(_pinstance);  // 释放 instance
        _pinstance = nullptr;
    }
}

static void processPosition(VLCkits * pkits)
{
    if (pkits->getisUserSeeking()) {
        // 正在拖动，不更新滑块，避免“弹回”
        return;
    }

    //百分比
    float pos = libvlc_media_player_get_position(pkits->mediaPlayer());
    pkits->setTimeSliderPos(pos * 100);

    // 获取总时长（毫秒）
    libvlc_time_t _totalSec = libvlc_media_player_get_length(pkits->mediaPlayer());
    libvlc_time_t totalSecs = _totalSec / 1000;

    // 获取当前播放时间（毫秒）
    libvlc_time_t curMs = libvlc_media_player_get_time(pkits->mediaPlayer());
    libvlc_time_t curSecs = curMs / 1000;


    int hh = curSecs / 3600;
    int mm = curSecs % 3600 / 60;
    int ss = curSecs % 60;
    int HH = totalSecs / 3600;
    int MM = totalSecs % 3600 / 60;
    int SS = totalSecs % 60;
    char buff[64] = {0};
    sprintf(buff, "%02d:%02d:%02d/%02d:%02d:%02d",
            hh, mm, ss, HH, MM, SS);
    QString str(buff);
    pkits->setTimeText(str);
}

static void processVolume(VLCkits * pkits)
{
    if (!pkits || !pkits->mediaPlayer()) {  // 双重保护
        return;
    }
    int val = libvlc_audio_get_volume(pkits->mediaPlayer());
    if(val == -1) {
        return;
    }
    pkits->setVolumePos(val);
}

static void vlc_callback(const libvlc_event_t *event, void *data)
{
    VLCkits *pkits = static_cast<VLCkits*>(data);
    if (!pkits) return;

    switch (event->type) {
    case libvlc_MediaPlayerPositionChanged:
        processPosition(pkits);
        break;
    case libvlc_MediaPlayerAudioVolume:
        processVolume(pkits);
        break;
    case libvlc_MediaPlayerEndReached: // 媒体播放结束
        emit pkits->mediaEndReached();
        break;
    default:
        break;
    }
}

void VLCkits::open(QWidget *m_videoWidget,QString path)
{


    if(_pmediaPlayer) {
        libvlc_media_player_stop(_pmediaPlayer);
        libvlc_media_player_release(_pmediaPlayer);
        _pmediaPlayer = nullptr;
    }

    if(_pmedia)
    {
        libvlc_media_release(_pmedia);
        _pmedia = nullptr;
    }

    path = QDir::toNativeSeparators(path);

    //创建媒体
    _pmedia = libvlc_media_new_path(_pinstance, path.toLocal8Bit().constData());
    if(!_pmedia)
    {
        qDebug() << " 创建媒体失败 " << path;
        return;
    }

    //创建媒体播放器对象
    _pmediaPlayer = libvlc_media_player_new_from_media(_pmedia);
    if(!_pmediaPlayer)
    {
        qDebug() << " 创建播放器失败！";
        libvlc_media_release(_pmedia);
        _pmedia = nullptr;
        return;
    }

    //在windows平台上指定媒体播放器渲染视频的窗口句柄
    libvlc_media_player_set_hwnd(_pmediaPlayer, (void*)m_videoWidget->winId());

    _peventManager = libvlc_media_player_event_manager(_pmediaPlayer);
    if (_peventManager) {
        libvlc_event_attach(_peventManager, libvlc_MediaPlayerPositionChanged, vlc_callback, this);
        libvlc_event_attach(_peventManager, libvlc_MediaPlayerAudioVolume, vlc_callback, this);
        libvlc_event_attach(_peventManager, libvlc_MediaPlayerEndReached, vlc_callback, this);
    }



    libvlc_media_parse_with_options(_pmedia, libvlc_media_parse_local, 1000);


    //    //应用保存的音量（如果有）(更保险)
    //    if (_pmediaPlayer && currvl >= 0) {
    //        libvlc_audio_set_volume(_pmediaPlayer, currvl);
    //    }

    //    //设置音量默认值
    //    libvlc_audio_set_volume(_pmediaPlayer, currvl);

    //启动媒体播放器
    libvlc_media_player_play(_pmediaPlayer);




}

void VLCkits::play()
{
    QPushButton *bt = qobject_cast<QPushButton*>(sender()); // 获取发送信号的按钮
    if(!bt || !_pmediaPlayer) return;

    if(_pmediaPlayer)
    {
        libvlc_state_t state = libvlc_media_player_get_state(_pmediaPlayer);
        if (state ==libvlc_Paused)
        {
            libvlc_media_player_play(_pmediaPlayer);
            bt->setIcon(QIcon(":/playctrlBar/pause.svg"));

        }else if(state ==libvlc_Playing)
        {
            libvlc_media_player_pause(_pmediaPlayer);
            bt->setIcon(QIcon(":/playctrlBar/play.svg"));
        }
    }
}

void VLCkits::pause()
{
    if (_pmediaPlayer)
    {
        libvlc_media_player_pause(_pmediaPlayer);
    }
}

void VLCkits::stop()
{
    if (_pmediaPlayer) {
        libvlc_media_player_stop(_pmediaPlayer);
        libvlc_media_player_set_position(_pmediaPlayer, 0);
        // 重置时间显示为 00:00:00
        libvlc_time_t totalMs = libvlc_media_player_get_length(_pmediaPlayer); // 获取总时长（毫秒）
        libvlc_time_t totalSecs = totalMs / 1000;

        int HH = totalSecs / 3600;
        int MM = (totalSecs % 3600) / 60;
        int SS = totalSecs % 60;

        char buff[64] = {0};
        sprintf(buff, "00:00:00/%02d:%02d:%02d", HH, MM, SS);
        QString str(buff);
        setTimeText(str);

        // 可选：重置进度条
        setTimeSliderPos(0);
    }
}

void VLCkits::setTimeSliderPos(int value)
{ //发送信号
    emit sigTimeSliderPos(value);
}

void VLCkits::setTimeText(const QString &str)
{ //发送信号
    emit sigTimeText(str);
}

void VLCkits::setVolumePos(int value)
{
    if(_pmediaPlayer){
        emit sigVolumeSliderPos(value);
    }
}

void VLCkits::setVolume(int value)
{
    if(_pmediaPlayer)
    {
        libvlc_audio_set_volume(_pmediaPlayer,value);
    }else{
        currvl = value;
        return;
    }
}


//进度
void VLCkits::setPosition(int value)
{
    libvlc_media_player_set_position(_pmediaPlayer, value / 100.0);
}

void VLCkits::onTimerUpdate()
{
    if (!_pmediaPlayer) {
        return;
    }
    // 获取播放状态，判断是否正在播放
    libvlc_state_t state = libvlc_media_player_get_state(_pmediaPlayer);

    if (state == libvlc_Playing || state == libvlc_Buffering) {
        processPosition(this); // 复用你已有的处理函数
    }
}

void VLCkits::setVideoWidget(QWidget* widget)
{
    if(_pmediaPlayer){
        libvlc_media_player_set_hwnd(_pmediaPlayer, (void *)widget->winId());
    }
}

bool VLCkits::isPlaying() const
{
    return _pmediaPlayer && libvlc_media_player_is_playing(_pmediaPlayer);
}

//列表循环模式
void VLCkits::setLoopMode(LoopMode mode)
{
    m_loopMode = mode;
}

VLCkits::LoopMode VLCkits::loopMode() const
{
    return m_loopMode;
}