player.cpp - mozsearch

++ // Copyright (C) 2017 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause

++

++ #include "player.h"

++ #include "playercontrols.h"

++ #include "playlistmodel.h"

++ #include "qmediaplaylist.h"

++ #include "videowidget.h"

++ #include "audiolevelmeter.h"

++

++ #include <QApplication>

++ #include <QAudioDevice>

++ #include <QAudioOutput>

++ #include <QBoxLayout>

++ #include <QComboBox>

++ #include <QDir>

++ #include <QFileDialog>

++ #include <QHBoxLayout>

++ #include <QLabel>

++ #include <QLineEdit>

++ #include <QListView>

++ #include <QMediaDevices>

++ #include <QMediaFormat>

++ #include <QMediaMetaData>

++ #include <QMessageBox>

++ #include <QPushButton>

++ #include <QSlider>

++ #include <QStandardPaths>

++ #include <QStatusBar>

++ #include <QVBoxLayout>

++ #include <QAudioBufferOutput>

++

++ using namespace Qt::Literals;

++ using namespace Qt::StringLiterals;

++

++ Player::Player(QWidget *parent) : QWidget(parent)

++ {

++     //! [create-objs]

++     m_player = new QMediaPlayer(this);

++     m_audioOutput = new QAudioOutput(this);

++     m_player->setAudioOutput(m_audioOutput);

++     //! [create-objs]

++     connect(m_player, &QMediaPlayer::durationChanged, this, &Player::durationChanged);

++     connect(m_player, &QMediaPlayer::positionChanged, this, &Player::positionChanged);

++     connect(m_player, &QMediaPlayer::metaDataChanged, this, &Player::metaDataChanged);

++     connect(m_player, &QMediaPlayer::mediaStatusChanged, this, &Player::statusChanged);

++     connect(m_player, &QMediaPlayer::bufferProgressChanged, this, &Player::bufferingProgress);

++     connect(m_player, &QMediaPlayer::hasVideoChanged, this, &Player::videoAvailableChanged);

++     connect(m_player, &QMediaPlayer::errorChanged, this, &Player::displayErrorMessage);

++     connect(m_player, &QMediaPlayer::tracksChanged, this, &Player::tracksChanged);

++

++     //! [2]

++     m_videoWidget = new VideoWidget(this);

++     m_videoWidget->resize(1280, 720);

++     m_player->setVideoOutput(m_videoWidget);

++

++     m_playlistModel = new PlaylistModel(this);

++     m_playlist = m_playlistModel->playlist();

++     //! [2]

++     connect(m_playlist, &QMediaPlaylist::currentIndexChanged, this,

++             &Player::playlistPositionChanged);

++

++     // audio level meter

++     m_audioBufferOutput = new QAudioBufferOutput(this);

++     m_player->setAudioBufferOutput(m_audioBufferOutput);

++     m_audioLevelMeter = new AudioLevelMeter(this);

++     connect(m_audioBufferOutput, &QAudioBufferOutput::audioBufferReceived,

++             m_audioLevelMeter, &AudioLevelMeter::onAudioBufferReceived);

++     connect(m_player, &QMediaPlayer::playingChanged,

++             m_audioLevelMeter, &AudioLevelMeter::deactivate);

++

++     // player layout

++     QBoxLayout *layout = new QVBoxLayout(this);

++

++     // display

++     QBoxLayout *displayLayout = new QHBoxLayout;

++     displayLayout->addWidget(m_videoWidget, 2);

++     displayLayout->addWidget(m_audioLevelMeter, 3);

++ #if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)

++     m_playlistView = new QListView();

++     m_playlistView->setModel(m_playlistModel);

++     m_playlistView->setCurrentIndex(m_playlistModel->index(m_playlist->currentIndex(), 0));

++     connect(m_playlistView, &QAbstractItemView::activated, this, &Player::jump);

++     displayLayout->addWidget(m_playlistView);

++ #endif

++     layout->addLayout(displayLayout);

++

++     // duration slider and label

++     QHBoxLayout *hLayout = new QHBoxLayout;

++

++     m_slider = new QSlider(Qt::Horizontal, this);

++     m_slider->setRange(0, m_player->duration());

++     connect(m_slider, &QSlider::sliderMoved, this, &Player::seek);

++     hLayout->addWidget(m_slider);

++

++     m_labelDuration = new QLabel();

++     m_labelDuration->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);

++     hLayout->addWidget(m_labelDuration);

++     layout->addLayout(hLayout);

++

++     // controls

++     QBoxLayout *controlLayout = new QHBoxLayout;

++     controlLayout->setContentsMargins(0, 0, 0, 0);

++

++     QPushButton *openButton = new QPushButton(tr("Open"), this);

++     connect(openButton, &QPushButton::clicked, this, &Player::open);

++     controlLayout->addWidget(openButton);

++     controlLayout->addStretch(1);

++

++     PlayerControls *controls = new PlayerControls();

++     controls->setState(m_player->playbackState());

++     controls->setVolume(m_audioOutput->volume());

++     controls->setMuted(controls->isMuted());

++

++     connect(controls, &PlayerControls::play, m_player, &QMediaPlayer::play);

++     connect(controls, &PlayerControls::pause, m_player, &QMediaPlayer::pause);

++     connect(controls, &PlayerControls::stop, m_player, &QMediaPlayer::stop);

++     connect(controls, &PlayerControls::next, m_playlist, &QMediaPlaylist::next);

++     connect(controls, &PlayerControls::previous, this, &Player::previousClicked);

++     connect(controls, &PlayerControls::changeVolume, m_audioOutput, &QAudioOutput::setVolume);

++     connect(controls, &PlayerControls::changeMuting, m_audioOutput, &QAudioOutput::setMuted);

++     connect(controls, &PlayerControls::changeRate, m_player, &QMediaPlayer::setPlaybackRate);

++     connect(controls, &PlayerControls::stop, m_videoWidget, QOverload<>::of(&QVideoWidget::update));

++

++     connect(m_player, &QMediaPlayer::playbackStateChanged, controls,

++             [controls](QMediaPlayer::PlaybackState arg) {

++         controls->setState(arg);

++     });

++     connect(m_audioOutput, &QAudioOutput::volumeChanged, controls, &PlayerControls::setVolume);

++     connect(m_audioOutput, &QAudioOutput::mutedChanged, controls, &PlayerControls::setMuted);

++

++     controlLayout->addWidget(controls);

++     controlLayout->addStretch(1);

++

++     m_fullScreenButton = new QPushButton(tr("FullScreen"), this);

++     m_fullScreenButton->setCheckable(true);

++     controlLayout->addWidget(m_fullScreenButton);

++

++     m_pitchCompensationButton = new QPushButton(tr("Pitch compensation"), this);

++     m_pitchCompensationButton->setCheckable(true);

++     switch (m_player->pitchCompensationAvailability()) {

++     case QMediaPlayer::PitchCompensationAvailability::AlwaysOn:

++         m_pitchCompensationButton->setEnabled(false);

++         m_pitchCompensationButton->setChecked(true);

++         m_pitchCompensationButton->setToolTip(

++                 u"Pitch compensation always enabled on this backend"_s);

++         break;

++     case QMediaPlayer::PitchCompensationAvailability::Unavailable:

++         m_pitchCompensationButton->setEnabled(false);

++         m_pitchCompensationButton->setChecked(false);

++         m_pitchCompensationButton->setToolTip(u"Pitch compensation unavailable on this backend"_s);

++         break;

++     case QMediaPlayer::PitchCompensationAvailability::Available:

++         m_pitchCompensationButton->setEnabled(true);

++         m_pitchCompensationButton->setChecked(m_player->pitchCompensation());

++         break;

++     default:

++         Q_UNREACHABLE();

++     }

++

++     controlLayout->addWidget(m_pitchCompensationButton);

++     connect(m_player, &QMediaPlayer::pitchCompensationChanged, this, [this] {

++         m_pitchCompensationButton->setChecked(m_player->pitchCompensation());

++     });

++     m_pitchCompensationButton->setChecked(m_player->pitchCompensation());

++     connect(m_pitchCompensationButton, &QPushButton::toggled, m_player,

++             &QMediaPlayer::setPitchCompensation);

++

++ #if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)

++     m_audioOutputCombo = new QComboBox(this);

++     controlLayout->addWidget(m_audioOutputCombo);

++

++     updateAudioDevices();

++

++     connect(m_audioOutputCombo, QOverload<int>::of(&QComboBox::activated), this,

++             &Player::audioOutputChanged);

++

++     QObject::connect(&m_mediaDevices, &QMediaDevices::audioOutputsChanged, this, [this] {

++         updateAudioDevices();

++     });

++ #endif

++

++     layout->addLayout(controlLayout);

++

++     // tracks

++     QGridLayout *tracksLayout = new QGridLayout;

++

++     m_audioTracks = new QComboBox(this);

++     connect(m_audioTracks, &QComboBox::activated, this, &Player::selectAudioStream);

++     tracksLayout->addWidget(new QLabel(tr("Audio Tracks:")), 0, 0);

++     tracksLayout->addWidget(m_audioTracks, 0, 1);

++

++     m_videoTracks = new QComboBox(this);

++     connect(m_videoTracks, &QComboBox::activated, this, &Player::selectVideoStream);

++     tracksLayout->addWidget(new QLabel(tr("Video Tracks:")), 1, 0);

++     tracksLayout->addWidget(m_videoTracks, 1, 1);

++

++     m_subtitleTracks = new QComboBox(this);

++     connect(m_subtitleTracks, &QComboBox::activated, this, &Player::selectSubtitleStream);

++     tracksLayout->addWidget(new QLabel(tr("Subtitle Tracks:")), 2, 0);

++     tracksLayout->addWidget(m_subtitleTracks, 2, 1);

++

++     layout->addLayout(tracksLayout);

++

++ #if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)

++     // metadata

++

++     QLabel *metaDataLabel = new QLabel(tr("Metadata for file:"));

++     layout->addWidget(metaDataLabel);

++

++     QGridLayout *metaDataLayout = new QGridLayout;

++     int key = QMediaMetaData::Title;

++     for (int i = 0; i < (QMediaMetaData::NumMetaData + 2) / 3; i++) {

++         for (int j = 0; j < 6; j += 2) {

++             m_metaDataLabels[key] = new QLabel(

++                     QMediaMetaData::metaDataKeyToString(static_cast<QMediaMetaData::Key>(key)));

++             if (key == QMediaMetaData::CoverArtImage) {

++                 m_metaDataFields[key] = new QLabel;

++             } else {

++                 auto lineEdit = new QLineEdit;

++                 lineEdit->setReadOnly(true);

++                 m_metaDataFields[key] = lineEdit;

++             }

++             m_metaDataLabels[key]->setDisabled(true);

++             m_metaDataFields[key]->setDisabled(true);

++             metaDataLayout->addWidget(m_metaDataLabels[key], i, j);

++             metaDataLayout->addWidget(m_metaDataFields[key], i, j + 1);

++             key++;

++             if (key == QMediaMetaData::NumMetaData)

++                 break;

++         }

++     }

++

++     layout->addLayout(metaDataLayout);

++ #endif

++

++ #if defined(Q_OS_QNX)

++     // On QNX, the main window doesn't have a title bar (or any other decorations).

++     // Create a status bar for the status information instead.

++     m_statusLabel = new QLabel;

++     m_statusBar = new QStatusBar;

++     m_statusBar->addPermanentWidget(m_statusLabel);

++     m_statusBar->setSizeGripEnabled(false); // Without mouse grabbing, it doesn't work very well.

++     layout->addWidget(m_statusBar);

++ #endif

++

++     if (!isPlayerAvailable()) {

++         QMessageBox::warning(this, tr("Service not available"),

++                              tr("The QMediaPlayer object does not have a valid service.\n"

++                                 "Please check the media service plugins are installed."));

++

++         controls->setEnabled(false);

++         if (m_playlistView)

++             m_playlistView->setEnabled(false);

++         openButton->setEnabled(false);

++         m_fullScreenButton->setEnabled(false);

++     }

++

++     metaDataChanged();

++ }

++

++ bool Player::isPlayerAvailable() const

++ {

++     return m_player->isAvailable();

++ }

++

++ void Player::open()

++ {

++     QFileDialog fileDialog(this);

++     fileDialog.setAcceptMode(QFileDialog::AcceptOpen);

++     fileDialog.setWindowTitle(tr("Open Files"));

++     fileDialog.setDirectory(QStandardPaths::standardLocations(QStandardPaths::MoviesLocation)

++                                     .value(0, QDir::homePath()));

++     if (fileDialog.exec() == QDialog::Accepted)

++         addToPlaylist(fileDialog.selectedUrls());

++ }

++

++ static bool isPlaylist(const QUrl &url) // Check for ".m3u" playlists.

++ {

++     if (!url.isLocalFile())

++         return false;

++     const QFileInfo fileInfo(url.toLocalFile());

++     return fileInfo.exists()

++             && !fileInfo.suffix().compare(QLatin1String("m3u"), Qt::CaseInsensitive);

++ }

++

++ void Player::addToPlaylist(const QList<QUrl> &urls)

++ {

++     const int previousMediaCount = m_playlist->mediaCount();

++     for (auto &url : urls) {

++         if (isPlaylist(url))

++             m_playlist->load(url);

++         else

++             m_playlist->addMedia(url);

++     }

++     if (m_playlist->mediaCount() > previousMediaCount) {

++         auto index = m_playlistModel->index(previousMediaCount, 0);

++         if (m_playlistView)

++             m_playlistView->setCurrentIndex(index);

++         jump(index);

++     }

++ }

++

++ void Player::durationChanged(qint64 duration)

++ {

++     m_duration = duration / 1000;

++     m_slider->setMaximum(duration);

++ }

++

++ void Player::positionChanged(qint64 progress)

++ {

++     if (!m_slider->isSliderDown())

++         m_slider->setValue(progress);

++

++     updateDurationInfo(progress / 1000);

++ }

++

++ void Player::metaDataChanged()

++ {

++     auto metaData = m_player->metaData();

++     setTrackInfo(metaData.value(QMediaMetaData::AlbumArtist).toString() + " - "_L1

++                  + metaData.value(QMediaMetaData::Title).toString());

++

++ #if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)

++     for (int i = 0; i < QMediaMetaData::NumMetaData; i++) {

++         if (QLineEdit *field = qobject_cast<QLineEdit *>(m_metaDataFields[i]))

++             field->clear();

++         else if (QLabel *label = qobject_cast<QLabel *>(m_metaDataFields[i]))

++             label->clear();

++         m_metaDataFields[i]->setDisabled(true);

++         m_metaDataLabels[i]->setDisabled(true);

++     }

++

++     for (auto &&[key, value] : metaData.asKeyValueRange()) {

++         int i = int(key);

++         if (key == QMediaMetaData::CoverArtImage) {

++             if (QLabel *cover = qobject_cast<QLabel *>(m_metaDataFields[key])) {

++                 QImage coverImage = value.value<QImage>();

++                 cover->setPixmap(QPixmap::fromImage(coverImage));

++             }

++         } else if (QLineEdit *field = qobject_cast<QLineEdit *>(m_metaDataFields[key])) {

++             QString stringValue = metaData.stringValue(key);

++             field->setText(stringValue);

++         }

++         m_metaDataFields[i]->setDisabled(false);

++         m_metaDataLabels[i]->setDisabled(false);

++     }

++

++     const QList<QMediaMetaData> tracks = m_player->videoTracks();

++     const int currentVideoTrack = m_player->activeVideoTrack();

++     if (currentVideoTrack >= 0 && currentVideoTrack < tracks.size()) {

++         const QMediaMetaData track = tracks.value(currentVideoTrack);

++

++         const QList<QMediaMetaData::Key> trackKeys = track.keys();

++         for (const QMediaMetaData::Key &key : std::as_const(trackKeys)) {

++             if (QLineEdit *field = qobject_cast<QLineEdit *>(m_metaDataFields[key])) {

++                 QString stringValue = track.stringValue(key);

++                 field->setText(stringValue);

++             }

++             m_metaDataFields[key]->setDisabled(true);

++             m_metaDataLabels[key]->setDisabled(true);

++         }

++     }

++ #endif

++ }

++

++ QString Player::trackName(const QMediaMetaData &metaData, int index)

++ {

++     QString name;

++     QString title = metaData.stringValue(QMediaMetaData::Title);

++     QLocale::Language lang = metaData.value(QMediaMetaData::Language).value<QLocale::Language>();

++

++     if (title.isEmpty()) {

++         if (lang == QLocale::Language::AnyLanguage)

++             name = tr("Track %1").arg(index + 1);

++         else

++             name = QLocale::languageToString(lang);

++     } else {

++         if (lang == QLocale::Language::AnyLanguage)

++             name = title;

++         else

++             name = title + " - ["_L1 + QLocale::languageToString(lang) + u']';

++     }

++     return name;

++ }

++

++ void Player::tracksChanged()

++ {

++     m_audioTracks->clear();

++     m_videoTracks->clear();

++     m_subtitleTracks->clear();

++

++     const auto audioTracks = m_player->audioTracks();

++     m_audioTracks->addItem(u"No audio"_s, -1);

++     for (int i = 0; i < audioTracks.size(); ++i)

++         m_audioTracks->addItem(trackName(audioTracks.at(i), i), i);

++     m_audioTracks->setCurrentIndex(m_player->activeAudioTrack() + 1);

++

++     const auto videoTracks = m_player->videoTracks();

++     m_videoTracks->addItem(u"No video"_s, -1);

++     for (int i = 0; i < videoTracks.size(); ++i)

++         m_videoTracks->addItem(trackName(videoTracks.at(i), i), i);

++     m_videoTracks->setCurrentIndex(m_player->activeVideoTrack() + 1);

++

++     m_subtitleTracks->addItem(u"No subtitles"_s, -1);

++     const auto subtitleTracks = m_player->subtitleTracks();

++     for (int i = 0; i < subtitleTracks.size(); ++i)

++         m_subtitleTracks->addItem(trackName(subtitleTracks.at(i), i), i);

++     m_subtitleTracks->setCurrentIndex(m_player->activeSubtitleTrack() + 1);

++ }

++

++ void Player::previousClicked()

++ {

++     // Go to previous track if we are within the first 5 seconds of playback

++     // Otherwise, seek to the beginning.

++     if (m_player->position() <= 5000) {

++         m_playlist->previous();

++     } else {

++         m_player->setPosition(0);

++     }

++ }

++

++ void Player::jump(const QModelIndex &index)

++ {

++     if (index.isValid()) {

++         m_playlist->setCurrentIndex(index.row());

++     }

++ }

++

++ void Player::playlistPositionChanged(int currentItem)

++ {

++     if (m_playlistView)

++         m_playlistView->setCurrentIndex(m_playlistModel->index(currentItem, 0));

++     m_player->setSource(m_playlist->currentMedia());

++ }

++

++ void Player::seek(int mseconds)

++ {

++     m_player->setPosition(mseconds);

++ }

++

++ void Player::statusChanged(QMediaPlayer::MediaStatus status)

++ {

++     handleCursor(status);

++

++     // handle status message

++     switch (status) {

++     case QMediaPlayer::NoMedia:

++     case QMediaPlayer::LoadedMedia:

++         setStatusInfo(QString());

++         break;

++     case QMediaPlayer::LoadingMedia:

++         setStatusInfo(tr("Loading..."));

++         break;

++     case QMediaPlayer::BufferingMedia:

++     case QMediaPlayer::BufferedMedia:

++         setStatusInfo(tr("Buffering %1%").arg(qRound(m_player->bufferProgress() * 100.)));

++         break;

++     case QMediaPlayer::StalledMedia:

++         setStatusInfo(tr("Stalled %1%").arg(qRound(m_player->bufferProgress() * 100.)));

++         break;

++     case QMediaPlayer::EndOfMedia:

++         QApplication::alert(this);

++         m_playlist->next();

++         break;

++     case QMediaPlayer::InvalidMedia:

++         displayErrorMessage();

++         break;

++     }

++ }

++

++ void Player::handleCursor(QMediaPlayer::MediaStatus status)

++ {

++ #ifndef QT_NO_CURSOR

++     if (status == QMediaPlayer::LoadingMedia || status == QMediaPlayer::BufferingMedia

++         || status == QMediaPlayer::StalledMedia)

++         setCursor(QCursor(Qt::BusyCursor));

++     else

++         unsetCursor();

++ #endif

++ }

++

++ void Player::bufferingProgress(float progress)

++ {

++     if (m_player->mediaStatus() == QMediaPlayer::StalledMedia)

++         setStatusInfo(tr("Stalled %1%").arg(qRound(progress * 100.)));

++     else

++         setStatusInfo(tr("Buffering %1%").arg(qRound(progress * 100.)));

++ }

++

++ void Player::videoAvailableChanged(bool available)

++ {

++     if (!available) {

++         disconnect(m_fullScreenButton, &QPushButton::clicked, m_videoWidget,

++                    &QVideoWidget::setFullScreen);

++         disconnect(m_videoWidget, &QVideoWidget::fullScreenChanged, m_fullScreenButton,

++                    &QPushButton::setChecked);

++         m_videoWidget->setFullScreen(false);

++     } else {

++         connect(m_fullScreenButton, &QPushButton::clicked, m_videoWidget,

++                 &QVideoWidget::setFullScreen);

++         connect(m_videoWidget, &QVideoWidget::fullScreenChanged, m_fullScreenButton,

++                 &QPushButton::setChecked);

++

++         if (m_fullScreenButton->isChecked())

++             m_videoWidget->setFullScreen(true);

++     }

++ }

++

++ void Player::selectAudioStream()

++ {

++     int stream = m_audioTracks->currentData().toInt();

++     m_player->setActiveAudioTrack(stream);

++ }

++

++ void Player::selectVideoStream()

++ {

++     int stream = m_videoTracks->currentData().toInt();

++     m_player->setActiveVideoTrack(stream);

++ }

++

++ void Player::selectSubtitleStream()

++ {

++     int stream = m_subtitleTracks->currentData().toInt();

++     m_player->setActiveSubtitleTrack(stream);

++ }

++

++ void Player::setTrackInfo(const QString &info)

++ {

++     m_trackInfo = info;

++

++     if (m_statusBar) {

++         m_statusBar->showMessage(m_trackInfo);

++         m_statusLabel->setText(m_statusInfo);

++     } else {

++         if (!m_statusInfo.isEmpty())

++             setWindowTitle(m_trackInfo + " | "_L1 + m_statusInfo);

++         else

++             setWindowTitle(m_trackInfo);

++     }

++ }

++

++ void Player::setStatusInfo(const QString &info)

++ {

++     m_statusInfo = info;

++

++     if (m_statusBar) {

++         m_statusBar->showMessage(m_trackInfo);

++         m_statusLabel->setText(m_statusInfo);

++     } else {

++         if (!m_statusInfo.isEmpty())

++             setWindowTitle(m_trackInfo + " | "_L1 + m_statusInfo);

++         else

++             setWindowTitle(m_trackInfo);

++     }

++ }

++

++ void Player::displayErrorMessage()

++ {

++     if (m_player->error() == QMediaPlayer::NoError)

++         return;

++     setStatusInfo(m_player->errorString());

++ }

++

++ void Player::updateDurationInfo(qint64 currentInfo)

++ {

++     QString tStr;

++     if (currentInfo || m_duration) {

++         QTime currentTime((currentInfo / 3600) % 60, (currentInfo / 60) % 60, currentInfo % 60,

++                           (currentInfo * 1000) % 1000);

++         QTime totalTime((m_duration / 3600) % 60, (m_duration / 60) % 60, m_duration % 60,

++                         (m_duration * 1000) % 1000);

++         QString format = m_duration > 3600 ? u"hh:mm:ss"_s : u"mm:ss"_s;

++         tStr = currentTime.toString(format) + " / "_L1 + totalTime.toString(format);

++     }

++     m_labelDuration->setText(tStr);

++ }

++

++ void Player::updateAudioDevices()

++ {

++     m_audioOutputCombo->clear();

++

++     m_audioOutputCombo->addItem(u"Default"_s, QVariant::fromValue(QAudioDevice()));

++     for (auto &deviceInfo : QMediaDevices::audioOutputs())

++         m_audioOutputCombo->addItem(deviceInfo.description(), QVariant::fromValue(deviceInfo));

++ }

++

++ void Player::audioOutputChanged(int index)

++ {

++     auto device = m_audioOutputCombo->itemData(index).value<QAudioDevice>();

++     m_player->audioOutput()->setDevice(device);

++ }

++

++ #include "moc_player.cpp"

Revision control