video_dialog.cpp

Go to the documentation of this file.

#include "video_dialog.h"
#include <QFileDialog>
#include <QDir>
#include <QFileInfo>
#include <QLineEdit>
#include <QDebug>
#include <QMessageBox>
#include <QDragEnterEvent>
#include <QMimeData>
#include <QSettings>
#include <cmath>
#include <QPixmap>
#include <QImage>
#include <QProgressDialog>
 
#include "PlotJuggler/svg_util.h"
 
#define QOI_IMPLEMENTATION
#include "qoi.h"
 
ImageLabel::ImageLabel(QWidget* parent) : QWidget(parent)
{
}
 
const QPixmap* ImageLabel::pixmap() const
{
  return &pix;
}
 
void ImageLabel::setPixmap(const QPixmap& pixmap)
{
  pix = pixmap;
}
 
void ImageLabel::paintEvent(QPaintEvent* event)
{
  QWidget::paintEvent(event);
 
  if (pix.isNull())
  {
    return;
  }
 
  QPainter painter(this);
  painter.setRenderHint(QPainter::Antialiasing);
 
  QSize rect_size = event->rect().size();
  QSize pix_size = pix.size();
  pix_size.scale(event->rect().size(), Qt::KeepAspectRatio);
 
  QPoint corner((rect_size.width() - pix_size.width()) / 2,
                (rect_size.height() - pix_size.height()) / 2);
 
  QPixmap scaled_pix =
      pix.scaled(pix_size, Qt::KeepAspectRatio, Qt::SmoothTransformation);
  painter.drawPixmap(corner, scaled_pix);
}
 
VideoDialog::VideoDialog(QWidget* parent) : QDialog(parent), ui(new Ui::VideoDialog)
{
  using namespace QtAV;
 
  ui->setupUi(this);
  _media_player = new AVPlayer(this);
  _media_player->audio()->setBackends(QStringList() << "null");
  _video_output = new VideoOutput(this);
 
  if (!_video_output->widget())
  {
    QMessageBox::warning(this, QString::fromLatin1("QtAV error"),
                         tr("Can not create video renderer"));
    return;
  }
  _media_player->setRenderer(_video_output);
  ui->verticalLayoutMain->addWidget(_video_output->widget(), 1.0);
 
  connect(_media_player, &AVPlayer::started, this, &VideoDialog::updateSlider);
 
  ui->lineEditReference->installEventFilter(this);
 
  QSettings settings;
  QString theme = settings.value("Preferences::theme", "light").toString();
  ui->clearButton->setIcon(LoadSvg(":/resources/svg/trash.svg", theme));
 
  _label = new ImageLabel(this);
  ui->verticalLayoutMain->addWidget(_label, 1.0);
  _label->setHidden(true);
}
 
VideoDialog::~VideoDialog()
{
  delete ui;
}
 
bool VideoDialog::loadFile(QString filename)
{
  if (!filename.isEmpty() && QFileInfo::exists(filename))
  {
    _media_player->play(filename);
    _media_player->pause(true);
    ui->lineFilename->setText(filename);
 
    _frame_reader = std::make_unique<QtAV::FrameReader>();
    _frame_reader->setMedia(filename);
    _compressed_frames.clear();
    ui->decodeButton->setEnabled(true);
 
    _decoded = false;
 
    _video_output->widget()->setHidden(false);
    _label->setHidden(true);
    return true;
  }
  return false;
}
 
QString VideoDialog::referenceCurve() const
{
  return ui->lineEditReference->text();
}
 
void VideoDialog::pause(bool paused)
{
  _media_player->pause(paused);
}
 
bool VideoDialog::isPaused() const
{
  return _media_player->isPaused();
}
 
void VideoDialog::on_loadButton_clicked()
{
  QSettings settings;
 
  QString directory_path =
      settings.value("VideoDialog.loadDirectory", QDir::currentPath()).toString();
 
  QString filename =
      QFileDialog::getOpenFileName(this, tr("Load Video"), directory_path, tr("(*.*)"));
  if (!loadFile(filename))
  {
    return;
  }
  directory_path = QFileInfo(filename).absolutePath();
  settings.setValue("VideoDialog.loadDirectory", directory_path);
}
 
void VideoDialog::updateSlider()
{
  const auto& fps = _media_player->statistics().video.frame_rate;
  qint64 duration_ms = _media_player->duration();
  int num_frames = static_cast<int>(qreal(duration_ms) * fps / 1000.0);
  ui->timeSlider->setRange(0, num_frames);
  _media_player->setNotifyInterval(static_cast<int>(1000 / fps));
  _media_player->pause(true);
 
  ui->timeSlider->setEnabled(true);
 
  if (_media_player->isSeekable() == false || duration_ms == 0)
  {
    QMessageBox msgBox(this);
    msgBox.setWindowTitle("Video is not seekable");
    msgBox.setText(tr("Video is not seekable. You will need to decode the video into "
                      "individual frames.\n"));
    msgBox.addButton(QMessageBox::Cancel);
    QPushButton* button = msgBox.addButton(tr("Decode!"), QMessageBox::YesRole);
    msgBox.setDefaultButton(button);
 
    int res = msgBox.exec();
 
    if (res < 0 || res == QMessageBox::Cancel)
    {
      ui->timeSlider->setEnabled(false);
    }
    else
    {
      on_decodeButton_clicked();
    }
  }
}
 
void VideoDialog::on_timeSlider_valueChanged(int num)
{
  double fps = _media_player->statistics().video.frame_rate;
  double period = 1000 / fps;
  qint64 frame_pos = static_cast<qint64>(qreal(num) * period);
 
  if (_decoded)
  {
    num = std::max(0, num);
    num = std::min(int(_compressed_frames.size() - 1), num);
 
    auto& frame = _compressed_frames[num];
    void* data = qoi_decode(frame.data, frame.length, &frame.info, 3);
    QImage image(static_cast<uchar*>(data), frame.info.width, frame.info.height,
                 QImage::Format_RGB888);
 
    // qDebug() << "ratio: " << double(3*frame.info.width*frame.info.height) /
    // double(frame.length);
 
    _label->setPixmap(QPixmap::fromImage(image));
    _label->repaint();
    free(data);
  }
  else
  {
    _media_player->setSeekType(QtAV::SeekType::AccurateSeek);
    _media_player->seek(frame_pos);
  }
}
 
void VideoDialog::seekByValue(double value)
{
  if (ui->radioButtonFrame->isChecked())
  {
    ui->timeSlider->setValue(static_cast<int>(value));
  }
  else if (ui->radioButtonTime->isChecked())
  {
    const auto& fps = _media_player->statistics().video.frame_rate;
    ui->timeSlider->setValue(static_cast<int>(value * 1000 / fps));
  }
}
 
bool VideoDialog::eventFilter(QObject* obj, QEvent* ev)
{
  if (obj != ui->lineEditReference)
  {
    return false;
  }
  if (ev->type() == QEvent::DragEnter)
  {
    auto event = static_cast<QDragEnterEvent*>(ev);
    const QMimeData* mimeData = event->mimeData();
    QStringList mimeFormats = mimeData->formats();
 
    QString& format = mimeFormats.front();
 
    QByteArray encoded = mimeData->data(format);
    QDataStream stream(&encoded, QIODevice::ReadOnly);
 
    if (format != "curveslist/add_curve")
    {
      return false;
    }
 
    QStringList curves;
    while (!stream.atEnd())
    {
      QString curve_name;
      stream >> curve_name;
      if (!curve_name.isEmpty())
      {
        curves.push_back(curve_name);
      }
    }
    if (curves.size() != 1)
    {
      return false;
    }
 
    _dragging_curve = curves.front();
    event->acceptProposedAction();
    return true;
  }
  else if (ev->type() == QEvent::Drop)
  {
    auto lineEdit = qobject_cast<QLineEdit*>(obj);
    lineEdit->setText(_dragging_curve);
  }
  return false;
}
 
void VideoDialog::on_clearButton_clicked()
{
  _media_player->stop();
  ui->lineFilename->setText("");
  ui->lineEditReference->setText("");
  ui->timeSlider->setEnabled(false);
  ui->timeSlider->setValue(0);
  ui->decodeButton->setEnabled(false);
 
  _decoded = false;
  _video_output->widget()->setHidden(false);
  _label->setHidden(true);
  _compressed_frames.clear();
}
 
void VideoDialog::on_decodeButton_clicked()
{
  if (_decoded)
  {
    return;
  }
 
  double fps = _media_player->statistics().video.frame_rate;
  QProgressDialog progress_dialog;
  progress_dialog.setWindowTitle("PlotJuggler Video");
  progress_dialog.setLabelText("Decoding file");
  progress_dialog.setWindowModality(Qt::ApplicationModal);
  progress_dialog.setRange(0, _media_player->duration() * fps / 1000);
  progress_dialog.setAutoClose(true);
  progress_dialog.setAutoReset(true);
  progress_dialog.show();
 
  int count = 0;
  while (_frame_reader->readMore())
  {
    while (_frame_reader->hasEnoughVideoFrames())
    {
      const QtAV::VideoFrame frame = _frame_reader->getVideoFrame();
      if (!frame)
      {
        continue;
      }
 
      QImage image = frame.toImage(QImage::Format_RGB888);
 
      CompressedFrame compressed_frame;
      compressed_frame.info.width = frame.width();
      compressed_frame.info.height = frame.height();
      compressed_frame.info.channels = 3;
      compressed_frame.info.colorspace = QOI_LINEAR;
      compressed_frame.data =
          qoi_encode(image.bits(), &compressed_frame.info, &compressed_frame.length);
 
      //      _frames.push_back( std::move(image) );
      _compressed_frames.push_back(std::move(compressed_frame));
 
      if (++count % 10 == 0)
      {
        progress_dialog.setValue(count);
        QApplication::processEvents();
        if (progress_dialog.wasCanceled())
        {
          _compressed_frames.clear();
          return;
        }
      }
    }
  }
  _decoded = true;
  _video_output->widget()->hide();
  _label->setHidden(false);
 
  ui->decodeButton->setEnabled(false);
  ui->timeSlider->setRange(0, _compressed_frames.size() - 1);
  on_timeSlider_valueChanged(ui->timeSlider->value());
}