Select Git revision
player.cpp 18.94 KiB
/*
* PeTrack - Software for tracking pedestrians movement in videos
* Copyright (C) 2010-2020 Forschungszentrum Jülich GmbH,
* Maik Boltes, Juliane Adrian, Ricardo Martin Brualla, Arne Graf, Paul Häger, Daniel Hillebrand,
* Deniz Kilic, Paul Lieberenz, Daniel Salden, Tobias Schrödter, Ann Katrin Seemann
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include <QApplication>
#include <QToolButton>
#include <QVBoxLayout>
#include <QPixmap>
#include <QSlider>
#include <QStyle>
#include <QLineEdit>
#include <QLabel>
#include <QIntValidator>
#include <QtConcurrent>
#include "player.h"
#include "animation.h"
#include "petrack.h"
#include "control.h"
#include "pMessageBox.h"
Player::Player(Animation *anim, QWidget *parent) : QWidget(parent)
{
int size = style()->pixelMetric(QStyle::PM_ToolBarIconSize);
QSize iconSize(size, size);
//play forward Button
mPlayForwardButton = new QToolButton;
mPlayForwardButton->setIcon(QPixmap(":/playF"));
mPlayForwardButton->setIconSize(iconSize);
connect(mPlayForwardButton, &QToolButton::clicked,this, [&](){this->play(PlayerState::FORWARD);});
//play backward Button
mPlayBackwardButton = new QToolButton;
mPlayBackwardButton->setIcon(QPixmap(":/playB"));
mPlayBackwardButton->setIconSize(iconSize);
connect(mPlayBackwardButton, &QToolButton::clicked, this, [&](){this->play(PlayerState::BACKWARD);});
//frame forward Button
mFrameForwardButton = new QToolButton;
mFrameForwardButton->setAutoRepeat(true);
mFrameForwardButton->setAutoRepeatDelay(400); // before repetition starts
mFrameForwardButton->setAutoRepeatInterval(1000./DEFAULT_FPS); // war: 40 // for 1000 ms / 25 fps
mFrameForwardButton->setIcon(QPixmap(":/skipF"));
mFrameForwardButton->setIconSize(iconSize);
connect(mFrameForwardButton,SIGNAL(clicked()),this,SLOT(frameForward()));
//frame backward Button
mFrameBackwardButton = new QToolButton;
mFrameBackwardButton->setAutoRepeat(true);
mFrameBackwardButton->setAutoRepeatDelay(400); // before repetition starts
mFrameBackwardButton->setAutoRepeatInterval(1000./DEFAULT_FPS); // war: 40 // for 1000 ms / 25 fps
mFrameBackwardButton->setIcon(QPixmap(":/skipB")); mFrameBackwardButton->setIconSize(iconSize);
connect(mFrameBackwardButton,SIGNAL(clicked()),this,SLOT(frameBackward()));
//pause button;
mPauseButton = new QToolButton;
mPauseButton->setIcon(QPixmap(":/pause"));
mPauseButton->setIconSize(iconSize);
connect(mPauseButton,SIGNAL(clicked()),this,SLOT(pause()));
//rec button;
mRecButton = new QToolButton;
mRecButton->setIcon(QPixmap(":/record"));
mRecButton->setIconSize(iconSize);
connect(mRecButton,SIGNAL(clicked()),this,SLOT(recStream()));
mRec = false;
//slider
mSlider = new QSlider(Qt::Horizontal);
mSlider->setTickPosition(QSlider::TicksAbove);
mSlider->setMinimumWidth(100);
connect(mSlider,SIGNAL(valueChanged(int)),this,SLOT(skipToFrame(int)));
//frame number
QFont f("Courier", 12, QFont::Bold); //Times Helvetica, Normal
mFrameNumValidator = new QIntValidator(0, 999999, this);
mFrameInNumValidator = new QIntValidator(0, 999999, this);
mFrameOutNumValidator = new QIntValidator(0, 999999, this);
mFrameInNum = new QLineEdit("");
mFrameInNum->setMaxLength(6);
mFrameInNum->setMaximumWidth(75);
mFrameInNum->setAlignment(Qt::AlignRight);
mFrameInNum->setValidator(mFrameInNumValidator);
mFrameInNum->setFont(f);
connect(mFrameInNum,SIGNAL(editingFinished()),this,SLOT(update()));
mFrameOutNum = new QLineEdit("");
mFrameOutNum->setMaxLength(8);
mFrameOutNum->setMaximumWidth(75);
mFrameOutNum->setAlignment(Qt::AlignRight);
mFrameOutNum->setValidator(mFrameOutNumValidator);
mFrameOutNum->setFont(f);
connect(mFrameOutNum,SIGNAL(editingFinished()),this,SLOT(update()));
mFrameNum = new QLineEdit("0");
mFrameNum->setMaxLength(8); // bedeutet maxminal 1,1 stunden
mFrameNum->setMaximumWidth(75); //5*sz.width() //62
mFrameNum->setAlignment(Qt::AlignRight);
mFrameNum->setValidator(mFrameNumValidator);
mFrameNum->setFont(f);
connect(mFrameNum,SIGNAL(editingFinished()),this,SLOT(skipToFrame()));
//frame number
mFpsNum = new QLineEdit(QString::number(DEFAULT_FPS));
mFpsNum->setMaxLength(8); // bedeutet maxminal 999,99
mFpsNum->setMaximumWidth(62); //5*sz.width()
mFpsNum->setAlignment(Qt::AlignRight);
mFpsNumValidator = new QDoubleValidator(0.0, 999.99, 2, this);
mFpsNum->setValidator(mFpsNumValidator);
mFpsNum->setFont(f);
connect(mFpsNum,SIGNAL(editingFinished()),this,SLOT(setFPS()));
QFont f2("Courier", 12, QFont::Normal); //Times Helvetica, Normal
mAtLabel = new QLabel("@");
mAtLabel->setFont(f2);
mSourceInLabel = new QLabel("In:");
mSourceInLabel->setFont(f2);
mSourceOutLabel = new QLabel("Out:"); mSourceOutLabel->setFont(f2);
mFpsLabel = new QLabel("fps");
mFpsLabel->setFont(f2);
// default value
mPlayerSpeedLimited = false;
//player layout
mPlayerLayout = new QHBoxLayout();
mPlayerLayout->addWidget(mPlayBackwardButton);
mPlayerLayout->addWidget(mFrameBackwardButton);
mPlayerLayout->addWidget(mPauseButton);
mPlayerLayout->addWidget(mFrameForwardButton);
mPlayerLayout->addWidget(mPlayForwardButton);
mPlayerLayout->addWidget(mRecButton);
mPlayerLayout->addWidget(mSourceInLabel);
mPlayerLayout->addWidget(mFrameInNum);
mPlayerLayout->addWidget(mSourceOutLabel);
mPlayerLayout->addWidget(mFrameOutNum);
mPlayerLayout->addWidget(mSlider);
mPlayerLayout->addWidget(mFrameNum);
mPlayerLayout->addWidget(mAtLabel);
mPlayerLayout->addWidget(mFpsNum);
mPlayerLayout->addWidget(mFpsLabel);
mPlayerLayout->setMargin(0);
mMainWindow = (class Petrack*) parent;
setLayout(mPlayerLayout);
setAnim(anim);
}
void Player::setFPS(double fps) // default: double fps=-1.
{
if (fps != -1)
{
mFpsNum->setText(QString::number(fps));
mFrameForwardButton->setAutoRepeatInterval(1000./fps); // for 1000 ms / 25 fps
mFrameBackwardButton->setAutoRepeatInterval(1000./fps); // for 1000 ms / 25 fps
}
mAnimation->setFPS(mFpsNum->text().toDouble());
}
void Player::setPlayerSpeedLimited(bool fixed)
{
mPlayerSpeedLimited = fixed;
}
void Player::togglePlayerSpeedLimited()
{
setPlayerSpeedLimited(!mPlayerSpeedLimited);
}
bool Player::getPlayerSpeedLimited() const
{
return mPlayerSpeedLimited;
}
void Player::setPlayerSpeedFixed(bool fixed)
{
mPlayerSpeedFixed = fixed;
}
void Player::setLooping(bool looping)
{
mLooping = looping;
}
void Player::setSpeedRelativeToRealtime(double factor){
setFPS(mAnimation->getOriginalFPS()*factor);
}
void Player::setAnim(Animation *anim)
{
if (anim)
{
pause();
mAnimation = anim;
int max = anim->getNumFrames()>1 ? anim->getNumFrames()-1 : 0;
setSliderMax(max);
mFrameNumValidator->setTop(max);
mFrameInNumValidator->setTop(anim->getSourceOutFrameNum());
mFrameOutNumValidator->setTop(anim->getMaxFrames());
}
}
bool Player::getPaused()
{
return mState == PlayerState::PAUSE;
}
void Player::setSliderMax(int max)
{
mSlider->setMaximum(max);
}
/**
* @brief Processes and displays the image mImg (set in forward() or backward())
*
* Heavy lifting is in Petrack::updateImage(). This method itself handles
* recording and updating the value of the video-slider.
*
* @return Boolean indicating if an frame was processed and displayed
*/
bool Player::updateImage()
{
if (mImg.empty())
{
pause();
return false;
}
qApp->processEvents();
#ifdef TIME_MEASUREMENT
double time1 = 0.0, tstart;
tstart = clock();
#endif
QFuture<void> future = QtConcurrent::run([&]() {mMainWindow->updateImage(mImg); });
future.waitForFinished();
if (mRec)
{
mAviFile.appendFrame((const unsigned char*) mImg.data, true);
}
#ifdef TIME_MEASUREMENT
time1 += clock() - tstart;
time1 = time1/CLOCKS_PER_SEC;
cout << " time(update image) = " << time1 << " sec." << endl;
#endif
mSlider->setValue(mAnimation->getCurrentFrameNum()); //(1000*mAnimation->getCurrentFrameNum())/mAnimation->getNumFrames());
mFrameNum->setText(QString().number(mAnimation->getCurrentFrameNum()));
return true;
}
bool Player::forward()
{
qApp->processEvents();#ifdef TIME_MEASUREMENT
double time1 = 0.0, tstart;
tstart = clock();
#endif
bool should_be_last_frame = mAnimation->getCurrentFrameNum() == mAnimation->getSourceOutFrameNum();
mImg = mAnimation->getNextFrame();
// check if animation is broken somewhere in the video
if (mImg.empty())
{
if (!should_be_last_frame)
{
debout << "Warning: video unexpected finished." << std::endl;
}
}
#ifdef TIME_MEASUREMENT
time1 += clock() - tstart;
time1 = time1/CLOCKS_PER_SEC;
cout << " time(load frame) = " << time1 << " sec." << endl;
#endif
return updateImage();
}
bool Player::backward()
{
qApp->processEvents();
#ifdef TIME_MEASUREMENT
double time1 = 0.0, tstart;
tstart = clock();
#endif
mImg = mAnimation->getPreviousFrame();
#ifdef TIME_MEASUREMENT
time1 += clock() - tstart;
time1 = time1/CLOCKS_PER_SEC;
cout << " time(load frame) = " << time1 << " sec." << endl;
#endif
return updateImage();
}
/**
* @brief Sets the state of the video player
*
* @see PlayerState
* @param state
*/
void Player::play(PlayerState state){
if(mState == PlayerState::PAUSE){
mState = state;
playVideo();
}else{
mState = state;
}
}
/**
* @brief Quasi MainLoop: Plays video in accordance to set frame rate
*
* This method is (indirectly) initiating calls to Player::updateImage
* and thus controls processing and display of video frames. The user has
* the option to limit playback speed, which is enforced here as well.
*
* The method is left, when the video is paused and reentered, when playing
* gets started again.
*/
void Player::playVideo(){
static QElapsedTimer timer;
int currentFrame = mAnimation->getCurrentFrameNum();
long long int overtime = 0;
while(mState != PlayerState::PAUSE){
// slow down the player speed for extrem fast video sequences (Jiayue China or 16fps cam99 basigo grid video)
if (mPlayerSpeedLimited || mPlayerSpeedFixed)
{
auto supposedDiff = static_cast<long long int>(1'000/mAnimation->getFPS());
if(timer.isValid()){
if(mPlayerSpeedFixed && mState == PlayerState::FORWARD){
overtime = std::max(0LL, overtime + (timer.elapsed() - supposedDiff));
if(overtime >= supposedDiff){
mAnimation->skipFrame(static_cast<int>(overtime / supposedDiff));
overtime = overtime % supposedDiff;
currentFrame = std::min(mAnimation->getCurrentFrameNum() + 1, mAnimation->getSourceOutFrameNum());
}
}
while(!timer.hasExpired(supposedDiff)){
qApp->processEvents();
}
}
timer.start();
}else{
timer.invalidate();
}
switch(mState){
case PlayerState::FORWARD:
mImg = mAnimation->getFrameAtIndex(currentFrame);
currentFrame++;
break;
case PlayerState::BACKWARD:
mImg = mAnimation->getFrameAtIndex(currentFrame);
currentFrame--;
break;
case PlayerState::PAUSE:
break;
}
if(!updateImage()){
mState = PlayerState::PAUSE;
if( mAnimation->getCurrentFrameNum() != 0 && mAnimation->getCurrentFrameNum() != mAnimation->getSourceOutFrameNum()){
debout << "Warning: video unexpectedly finished." << std::endl;
}
}else{
if( mLooping && mMainWindow->getControlWidget()->trackOnlineCalc->checkState() == Qt::Checked)
{
PWarning(this, "Error: No tracking while looping", "Looping and tracking are incompatible. Please disable one first.");
mState = PlayerState::PAUSE;
break;
}else if(mLooping)
{
if(mState == PlayerState::FORWARD && mAnimation->getCurrentFrameNum() == mAnimation->getSourceOutFrameNum())
{
currentFrame = 0;
}else if(mState == PlayerState::BACKWARD && mAnimation->getCurrentFrameNum() == 0)
{
currentFrame = mAnimation->getSourceOutFrameNum();
}
}
}
}
timer.invalidate();
}
bool Player::frameForward()
{
pause(); return forward();
}
bool Player::frameBackward()
{
pause();
return backward();
}
void Player::pause()
{
mState = PlayerState::PAUSE;
mMainWindow->setShowFPS(0.);
}
/**
* @brief Toggles pause/play for use via spacebar
*/
void Player::togglePlayPause()
{
static PlayerState lastState;
if (mState != PlayerState::PAUSE)
{
lastState = mState;
pause();
}
else
{
play(lastState);
}
}
/**
* @brief Toggles recording and saving of recording
*
* If already recording, the method stops the recording and saves it to
* a user-given file. If recording hasn't started, this method starts it.
*
* Actual recording happens in Player::updateImage()
*/
void Player::recStream()
{
if (mAnimation->isCameraLiveStream() || mAnimation->isVideo() || mAnimation->isImageSequence() || mAnimation->isStereoVideo())
{
// video temp path/file name
QString videoTmp = QDir::tempPath()+"/petrack-video-record.avi";
if (mRec) //stop recording and save recorded stream to disk
{
mRec = false;
mRecButton->setIcon(QPixmap(":/record"));
mAviFile.close();
QString dest;
QFileDialog fileDialog(this,
tr("Select file for saving video output"),
nullptr,
tr("Video (*.*);;AVI-File (*.avi);;All supported types (*.avi *.mp4);;All files (*.*)"));
fileDialog.setAcceptMode(QFileDialog::AcceptSave);
fileDialog.setFileMode(QFileDialog::AnyFile);
fileDialog.setDefaultSuffix("");
if( fileDialog.exec() )
dest = fileDialog.selectedFiles().at(0);
if (dest == nullptr)
return;
if (QFile::exists(dest))
QFile::remove(dest);
QProgressDialog progress("Save Video File",nullptr,0,2,mMainWindow);
progress.setWindowTitle("Save Video File");
progress.setWindowModality(Qt::WindowModal);
progress.setVisible(true);
progress.setValue(0);
progress.setLabelText(QString("save video ..."));
qApp->processEvents();
progress.setValue(1);
if (!QFile(videoTmp).copy(dest))
{
PCritical(this, tr("PeTrack"),
tr("Error: Could not save video file!"));
}else
{
mMainWindow->statusBar()->showMessage(tr("Saved video file to %1.").arg(dest), 5000);
if (!QFile(videoTmp).remove())
debout << "Could not remove tmp-file: " << videoTmp << std::endl;
progress.setValue(2);
}
}else // open video writer
{
if (mAviFile.open(videoTmp.toStdString().c_str(), mImg.cols, mImg.rows, 8*mImg.channels(), mAnimation->getFPS()))
{
mRec = true;
mRecButton->setIcon(QPixmap(":/stop-record"));
}else
{
debout << "error: could not open video output file!" << std::endl;
}
}
}
}
bool Player::skipToFrame(int f) // [0..mAnimation->getNumFrames()-1]
{
if (f == mAnimation->getCurrentFrameNum())
{
return false;
}
pause();
mImg = mAnimation->getFrameAtIndex(f);
return updateImage();
}
bool Player::skipToFrame() // [0..mAnimation->getNumFrames()-1]
{
if (mFrameNum->text().toInt() < getFrameInNum())
mFrameNum->setText(QString::number(getFrameInNum()));
if (mFrameNum->text().toInt() > getFrameOutNum())
mFrameNum->setText(QString::number(getFrameOutNum()));
return skipToFrame(mFrameNum->text().toInt());
}
/**
* @brief Properly updates FrameInNum and FrameOutNum
*/
void Player::update()
{
if constexpr (true || !mMainWindow->isLoading())
{
if( mFrameNum->text().toInt() < mFrameInNum->text().toInt() )
{
mFrameNum->setText(mFrameInNum->text());
skipToFrame(mFrameNum->text().toInt());
}
if( mFrameNum->text().toInt() > mFrameOutNum->text().toInt() )
{
mFrameNum->setText(mFrameOutNum->text());
skipToFrame(mFrameNum->text().toInt());
}
mSlider->setMinimum(getFrameInNum());
mSlider->setMaximum(getFrameOutNum());
mFrameInNumValidator->setTop(getFrameOutNum()-1);
mFrameNumValidator->setBottom(getFrameInNum());
mFrameNumValidator->setTop(getFrameOutNum());
mAnimation->updateSourceInFrameNum(mFrameInNum->text().toInt());
mAnimation->updateSourceOutFrameNum(mFrameOutNum->text().toInt());
mMainWindow->updateWindowTitle();
}
}
int Player::getFrameInNum()
{
if (mFrameInNum->text() == "")
return -1;
return mFrameInNum->text().toInt();
}
void Player::setFrameInNum(int in)
{
if (in == -1)
in = 0;
mFrameInNum->setText(QString::number(in));
mFrameInNumValidator->setTop(getFrameOutNum()-1);
mFrameNumValidator->setBottom(getFrameInNum());
mFrameNumValidator->setTop(getFrameOutNum());
}
int Player::getFrameOutNum()
{
if (mFrameOutNum->text() == "")
return -1;
return mFrameOutNum->text().toInt();
}
void Player::setFrameOutNum(int out)
{
if (out == -1)
out = mAnimation->getMaxFrames()-1;
mFrameOutNum->setText(QString::number(out));
mFrameInNumValidator->setTop(/*out*/getFrameOutNum()-1);
mFrameNumValidator->setBottom(getFrameInNum());
mFrameNumValidator->setTop(/*out*/getFrameOutNum());
}
int Player::getPos()
{
return mAnimation->getCurrentFrameNum();
}
#include "moc_player.cpp"