File indexing completed on 2024-12-22 04:40:20

 /*
     SPDX-FileCopyrightText: 2007-2009 Sergio Pistone <sergio_pistone@yahoo.com.ar>
     SPDX-FileCopyrightText: 2010-2022 Mladen Milinkovic <max@smoothware.net>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "videoplayer.h"
 #include "scconfig.h"
 
 #include "videoplayer/backend/glrenderer.h"
 
 #include <math.h>
 
 #include <QTimer>
 #include <QFileInfo>
 #include <QApplication>
 #include <QEvent>
 
 #include <QDebug>
 
 #include <KLocalizedString>
 
 #define VOLUME_MULTIPLIER (double(qMax(1, SCConfig::volumeAmplification())) / 3.)
 
 using namespace SubtitleComposer;
 
 
 VideoPlayer::VideoPlayer()
     : m_player(new FFPlayer(this)),
       m_videoWidget(nullptr),
       m_filePath(),
       m_state(Initialized),
       m_duration(-1.0),
       m_fps(-1.0),
       m_playSpeed(.0),
       m_textStreams(),
       m_activeAudioStream(-2),
       m_audioStreams(),
       m_muted(false),
       m_volume(100.0)
 {
     m_player->renderer()->setOverlay(&m_subOverlay);
 
     setupNotifications();
 }
 
 VideoPlayer::~VideoPlayer()
 {
 }
 
 VideoPlayer *
 VideoPlayer::instance()
 {
     static VideoPlayer *player = nullptr;
     if(!player)
         player = new VideoPlayer();
     return player;
 }
 
 bool
 VideoPlayer::init(QWidget *videoContainer)
 {
     if(!m_videoWidget) {
         m_videoWidget = new VideoWidget(videoContainer);
         m_videoWidget->setVideoLayer(m_player->renderer());
 
         connect(m_videoWidget, &VideoWidget::doubleClicked, this, &VideoPlayer::doubleClicked);
         connect(m_videoWidget, &VideoWidget::rightClicked, this, &VideoPlayer::rightClicked);
         connect(m_videoWidget, &VideoWidget::leftClicked, this, &VideoPlayer::leftClicked);
         connect(m_videoWidget, &VideoWidget::wheelUp, this, &VideoPlayer::wheelUp);
         connect(m_videoWidget, &VideoWidget::wheelDown, this, &VideoPlayer::wheelDown);
     } else {
         m_videoWidget->setParent(videoContainer);
     }
     reset();
 
     return true;
 }
 
 void
 VideoPlayer::reset()
 {
     m_filePath.clear();
 
     m_duration = -1.0;
     m_fps = -1.0;
 
     m_activeAudioStream = -2;
     m_textStreams.clear();
     m_audioStreams.clear();
 
     m_state = Initialized;
 
     if(m_videoWidget)
         m_videoWidget->videoLayer()->hide();
 }
 
 bool
 VideoPlayer::playOnLoad()
 {
     const QWidget *topLevel = m_videoWidget->topLevelWidget();
     const QWidget *dockWaveform = topLevel->findChild<QWidget *>(QStringLiteral("waveform_dock"));
     const QWidget *dockVideo = topLevel->findChild<QWidget *>(QStringLiteral("player_dock"));
     return SCConfig::videoAutoPlay() && (dockVideo->isVisible() || dockWaveform->isVisible());
 }
 
 bool
 VideoPlayer::openFile(const QString &filePath)
 {
     Q_ASSERT(m_state == Initialized || m_state == Stopped);
 
     QFileInfo fileInfo(filePath);
     if(!fileInfo.exists() || !fileInfo.isFile() || !fileInfo.isReadable()) {
         emit fileOpenError(filePath, i18n("File does not exist."));   // operation will never succeed
         return false;
     }
 
     m_filePath = filePath;
     m_state = Opening;
 
     if(!m_player->open(fileInfo.absoluteFilePath().toUtf8()))
         return false;
 
     if(m_player->paused() == playOnLoad())
         m_player->pauseToggle();
 
     return true;
 }
 
 void
 VideoPlayer::closeFile()
 {
     if(m_state < Opening)
         return;
     m_player->close();
     reset();
     emit fileClosed();
 }
 
 void
 VideoPlayer::play()
 {
     if(m_state <= Opening || m_state == Playing)
         return;
     if(m_state < Playing)
         openFile(m_filePath);
     if(m_state == Paused)
         m_player->pauseToggle();
 }
 
 void
 VideoPlayer::pause()
 {
     if(m_state <= Opening || m_state == Paused)
         return;
     m_player->pauseToggle();
 }
 
 void
 VideoPlayer::togglePlayPaused()
 {
     if(m_state == Playing)
         pause();
     else if(m_state > Opening)
         play();
 }
 
 bool
 VideoPlayer::seek(double seconds)
 {
     if(m_state <= Stopped)
         return false;
     m_player->seek(qBound(0., seconds, m_duration));
     return true;
 }
 
 bool
 VideoPlayer::step(int frameOffset)
 {
     if(m_state <= Stopped)
         return false;
     m_player->stepFrame(frameOffset);
     return true;
 }
 
 bool
 VideoPlayer::stop()
 {
     if(m_state <= Stopped)
         return false;
     m_player->close();
     return true;
 }
 
 bool
 VideoPlayer::selectAudioStream(int streamIndex)
 {
     if(m_state <= VideoPlayer::Opening || streamIndex < 0 || streamIndex >= m_audioStreams.size())
         return false;
 
     if(m_activeAudioStream != streamIndex) {
         m_activeAudioStream = streamIndex;
         m_player->activeAudioStream(streamIndex);
         emit activeAudioStreamChanged(streamIndex);
     }
     return true;
 }
 
 void
 VideoPlayer::playSpeed(double newRate)
 {
     if(m_state <= Opening || newRate < .05 || newRate > 8.)
         return;
 
     m_player->setSpeed(newRate);
 }
 
 void
 VideoPlayer::increaseVolume(double amount)
 {
     setVolume(m_volume + amount);
     setMuted(false);
 }
 
 void
 VideoPlayer::decreaseVolume(double amount)
 {
     setVolume(m_volume - amount);
 }
 
 void
 VideoPlayer::setVolume(double volume)
 {
     volume = qBound(0., volume, 100.);
     m_player->setVolume(VOLUME_MULTIPLIER * volume / 100.);
 
     if(m_volume != volume)
         emit volumeChanged(m_volume = volume);
 }
 
 void
 VideoPlayer::setMuted(bool muted)
 {
     m_player->setMuted(muted);
 
     if(m_muted == muted)
         return;
 
     m_muted = muted;
 
     emit muteChanged(m_muted);
 }
 
 void
 VideoPlayer::setupNotifications()
 {
     connect(m_player, &FFPlayer::mediaLoaded, this, [this](){
         m_player->renderer()->reset();
         emit fileOpened(m_filePath);
         m_fps = m_player->videoFPS();
         emit fpsChanged(m_fps);
         m_videoWidget->videoLayer()->show();
     });
     connect(m_player, &FFPlayer::stateChanged, this, [this](FFPlayer::State ffs){
         if(m_state == Initialized) // video file is closed don't notify play/pause/stop
             return;
         static const QMap<FFPlayer::State, State> stateMap
             {{ FFPlayer::Stopped, Stopped }, { FFPlayer::Playing, Playing }, { FFPlayer::Paused, Paused }};
         const State state = stateMap[ffs];
         if(m_state != state) switch(m_state = state) {
         case Stopped: emit stopped(); break;
         case Playing: emit playing(); break;
         case Paused: emit paused(); break;
         default: break; // not possible
         }
     });
     connect(m_player->renderer(), &GLRenderer::resolutionChanged, this, [this](){
         m_videoWidget->setVideoResolution(m_player->videoWidth(), m_player->videoHeight(), m_player->videoSAR());
         m_videoWidget->videoLayer()->show();
     });
 
     connect(m_player, &FFPlayer::positionChanged, this, &VideoPlayer::positionChanged);
 
     connect(m_player, &FFPlayer::durationChanged, this, [this](double dur){
         if(m_duration != dur) emit durationChanged(m_duration = dur);
     });
     connect(m_player, &FFPlayer::speedChanged, this, [this](double speed){
         if(m_playSpeed != speed) emit playSpeedChanged(m_playSpeed = speed);
     });
 
     connect(m_player, &FFPlayer::volumeChanged, this, [this](double volume){
         if(m_volume != (volume = volume * 100. / VOLUME_MULTIPLIER)) {
             m_volume = volume;
             if(!m_muted) emit volumeChanged(m_volume);
         }
     });
     connect(m_player, &FFPlayer::muteChanged, this, [this](bool muted){
         if(m_muted != muted) emit muteChanged(m_muted = muted);
     });
 
     //connect(m_player, &FFPlayer::videoStreamsChanged, this, [this](const QStringList &streams){});
     connect(m_player, &FFPlayer::audioStreamsChanged, this, [this](const QStringList &streams){
         if(m_activeAudioStream >= 0)
             m_player->activeAudioStream(m_activeAudioStream);
         emit audioStreamsChanged(m_audioStreams = streams);
         emit activeAudioStreamChanged(m_activeAudioStream = m_player->activeAudioStream());
     });
     connect(m_player, &FFPlayer::subtitleStreamsChanged, this, [this](const QStringList &streams){
         emit textStreamsChanged(m_textStreams = streams);
     });
 }