avmedia/source/qt6/QtPlayer.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <sal/config.h>
  11
  12 #include <QtCore/QUrl>
  13 #include <QtMultimedia/QAudioOutput>
  14 #include <QtMultimedia/QMediaMetaData>
  15 #include <QtMultimediaWidgets/QVideoWidget>
  16 #include <QtWidgets/QLabel>
  17 #include <QtWidgets/QLayout>
  18
  19 #include <cppuhelper/supportsservice.hxx>
  20 #include <sal/log.hxx>
  21 #include <rtl/string.hxx>
  22 #include <tools/link.hxx>
  23 #include <vcl/BitmapTools.hxx>
  24 #include <vcl/graph.hxx>
  25 #include <vcl/qt/QtUtils.hxx>
  26 #include <vcl/svapp.hxx>
  27 #include <vcl/syschild.hxx>
  28 #include <vcl/sysdata.hxx>
  29 #include <vcl/timer.hxx>
  30
  31 #include <gstwindow.hxx>
  32 #include "QtFrameGrabber.hxx"
  33 #include "QtPlayer.hxx"
  34
  35 #include <QtPlayer.moc>
  36
  37 using namespace ::com::sun::star;
  38
  39 namespace avmedia::qt
  40 {
  41 QtPlayer::QtPlayer()
  42     : QtPlayer_BASE(m_aMutex)
  43     , m_lListener(m_aMutex)
  44     , m_pMediaWidgetParent(nullptr)
  45 {
  46 }
  47
  48 bool QtPlayer::create(const OUString& rURL)
  49 {
  50     const QUrl aQUrl(toQString(rURL));
  51     if (!aQUrl.isValid() || !aQUrl.isLocalFile())
  52         return false;
  53
  54     m_xMediaPlayer = std::make_unique<QMediaPlayer>();
  55     m_xMediaPlayer->setSource(aQUrl);
  56     QAudioOutput* pAudioOutput = new QAudioOutput;
  57     pAudioOutput->setVolume(50);
  58     m_xMediaPlayer->setAudioOutput(pAudioOutput);
  59
  60     return true;
  61 }
  62
  63 void SAL_CALL QtPlayer::start()
  64 {
  65     osl::MutexGuard aGuard(m_aMutex);
  66
  67     assert(m_xMediaPlayer);
  68     m_xMediaPlayer->play();
  69 }
  70
  71 void SAL_CALL QtPlayer::stop()
  72 {
  73     osl::MutexGuard aGuard(m_aMutex);
  74
  75     assert(m_xMediaPlayer);
  76     // don't use QMediaPlayer::stop because XPlayer::stop should leave the position unchanged
  77     m_xMediaPlayer->pause();
  78 }
  79
  80 sal_Bool SAL_CALL QtPlayer::isPlaying()
  81 {
  82     osl::MutexGuard aGuard(m_aMutex);
  83
  84 #if QT_VERSION >= QT_VERSION_CHECK(6, 5, 0)
  85     assert(m_xMediaPlayer);
  86     return m_xMediaPlayer->isPlaying();
  87 #else
  88     return false;
  89 #endif
  90 }
  91
  92 double SAL_CALL QtPlayer::getDuration()
  93 {
  94     osl::MutexGuard aGuard(m_aMutex);
  95
  96     assert(m_xMediaPlayer);
  97     return m_xMediaPlayer->duration() / 1000.0;
  98 }
  99
 100 void SAL_CALL QtPlayer::setMediaTime(double fTime)
 101 {
 102     osl::MutexGuard aGuard(m_aMutex);
 103
 104     assert(m_xMediaPlayer);
 105     m_xMediaPlayer->setPosition(fTime * 1000);
 106 }
 107
 108 double SAL_CALL QtPlayer::getMediaTime()
 109 {
 110     osl::MutexGuard aGuard(m_aMutex);
 111
 112     assert(m_xMediaPlayer);
 113     return m_xMediaPlayer->position() / 1000.0;
 114 }
 115
 116 void SAL_CALL QtPlayer::setPlaybackLoop(sal_Bool bSet)
 117 {
 118     assert(m_xMediaPlayer);
 119     const int nLoops = bSet ? QMediaPlayer::Infinite : QMediaPlayer::Once;
 120     m_xMediaPlayer->setLoops(nLoops);
 121 }
 122
 123 sal_Bool SAL_CALL QtPlayer::isPlaybackLoop()
 124 {
 125     assert(m_xMediaPlayer);
 126     return m_xMediaPlayer->loops() == QMediaPlayer::Infinite;
 127 }
 128
 129 void SAL_CALL QtPlayer::setVolumeDB(sal_Int16 nVolumeDB)
 130 {
 131     osl::MutexGuard aGuard(m_aMutex);
 132
 133     // range is -40 for silence to 0 for full volume
 134     const sal_Int16 nVolume = std::clamp<sal_Int16>(nVolumeDB, -40, 0);
 135     double fValue = (nVolume + 40) / 40.0;
 136     assert(m_xMediaPlayer);
 137     QAudioOutput* pAudioOutput = m_xMediaPlayer->audioOutput();
 138     assert(pAudioOutput);
 139     pAudioOutput->setVolume(fValue);
 140 }
 141
 142 sal_Int16 SAL_CALL QtPlayer::getVolumeDB()
 143 {
 144     osl::MutexGuard aGuard(m_aMutex);
 145
 146     assert(m_xMediaPlayer);
 147     QAudioOutput* pAudioOutput = m_xMediaPlayer->audioOutput();
 148     assert(pAudioOutput);
 149
 150     double fVolume = pAudioOutput->volume();
 151     return (fVolume * 40) - 40;
 152 }
 153
 154 void SAL_CALL QtPlayer::setMute(sal_Bool bSet)
 155 {
 156     osl::MutexGuard aGuard(m_aMutex);
 157
 158     assert(m_xMediaPlayer);
 159     QAudioOutput* pAudioOutput = m_xMediaPlayer->audioOutput();
 160     assert(pAudioOutput);
 161     pAudioOutput->setMuted(bSet);
 162 }
 163
 164 sal_Bool SAL_CALL QtPlayer::isMute()
 165 {
 166     osl::MutexGuard aGuard(m_aMutex);
 167
 168     assert(m_xMediaPlayer);
 169     QAudioOutput* pAudioOutput = m_xMediaPlayer->audioOutput();
 170     assert(pAudioOutput);
 171     return pAudioOutput->isMuted();
 172 }
 173
 174 awt::Size SAL_CALL QtPlayer::getPreferredPlayerWindowSize()
 175 {
 176     osl::MutexGuard aGuard(m_aMutex);
 177
 178     assert(m_xMediaPlayer);
 179     const QMediaMetaData aMetaData = m_xMediaPlayer->metaData();
 180     const QVariant aResolutionVariant = aMetaData.value(QMediaMetaData::Resolution);
 181     if (aResolutionVariant.canConvert<QSize>())
 182     {
 183         const QSize aResolution = aResolutionVariant.value<QSize>();
 184         return awt::Size(aResolution.width(), aResolution.height());
 185     }
 186
 187     return awt::Size(0, 0);
 188 }
 189
 190 uno::Reference<::media::XPlayerWindow>
 191     SAL_CALL QtPlayer::createPlayerWindow(const uno::Sequence<uno::Any>& rArguments)
 192 {
 193     osl::MutexGuard aGuard(m_aMutex);
 194
 195     if (rArguments.getLength() > 1)
 196         rArguments[1] >>= m_aPlayerWidgetRect;
 197
 198     if (rArguments.getLength() <= 2)
 199     {
 200         uno::Reference<::media::XPlayerWindow> xRet = new ::avmedia::gstreamer::Window;
 201         return xRet;
 202     }
 203
 204     sal_IntPtr pIntPtr = 0;
 205     rArguments[2] >>= pIntPtr;
 206     SystemChildWindow* pParentWindow = reinterpret_cast<SystemChildWindow*>(pIntPtr);
 207     if (!pParentWindow)
 208         return nullptr;
 209
 210     const SystemEnvData* pParentEnvData = pParentWindow->GetSystemData();
 211     if (!pParentEnvData)
 212         return nullptr;
 213
 214     m_pMediaWidgetParent = static_cast<QWidget*>(pParentEnvData->pWidget);
 215     assert(m_pMediaWidgetParent);
 216
 217     // while media is loading, QMediaPlayer::hasVideo doesn't yet return
 218     // whether media actually has video; defer creating audio/video widget
 219     if (m_xMediaPlayer->mediaStatus() == QMediaPlayer::LoadingMedia)
 220     {
 221         connect(m_xMediaPlayer.get(), &QMediaPlayer::mediaStatusChanged, this,
 222                 &QtPlayer::createMediaPlayerWidget, Qt::SingleShotConnection);
 223     }
 224     else
 225     {
 226         createMediaPlayerWidget();
 227     }
 228
 229     uno::Reference<::media::XPlayerWindow> xRet = new ::avmedia::gstreamer::Window;
 230     return xRet;
 231 }
 232
 233 uno::Reference<media::XFrameGrabber> SAL_CALL QtPlayer::createFrameGrabber()
 234 {
 235     osl::MutexGuard aGuard(m_aMutex);
 236
 237     rtl::Reference<QtFrameGrabber> xFrameGrabber = new QtFrameGrabber(m_xMediaPlayer->source());
 238     return xFrameGrabber;
 239 }
 240
 241 void SAL_CALL
 242 QtPlayer::addPlayerListener(const css::uno::Reference<css::media::XPlayerListener>& rListener)
 243 {
 244     m_lListener.addInterface(cppu::UnoType<css::media::XPlayerListener>::get(), rListener);
 245     if (isReadyToPlay())
 246     {
 247         css::lang::EventObject aEvent;
 248         aEvent.Source = getXWeak();
 249         rListener->preferredPlayerWindowSizeAvailable(aEvent);
 250     }
 251     else
 252     {
 253         installNotify();
 254     }
 255 }
 256
 257 void SAL_CALL
 258 QtPlayer::removePlayerListener(const css::uno::Reference<css::media::XPlayerListener>& rListener)
 259 {
 260     m_lListener.removeInterface(cppu::UnoType<css::media::XPlayerListener>::get(), rListener);
 261 }
 262
 263 OUString SAL_CALL QtPlayer::getImplementationName()
 264 {
 265     return u"com.sun.star.comp.avmedia.Player_Qt"_ustr;
 266 }
 267
 268 sal_Bool SAL_CALL QtPlayer::supportsService(const OUString& rServiceName)
 269 {
 270     return cppu::supportsService(this, rServiceName);
 271 }
 272
 273 uno::Sequence<OUString> SAL_CALL QtPlayer::getSupportedServiceNames()
 274 {
 275     return { u"com.sun.star.media.Player_Qt"_ustr };
 276 }
 277
 278 void SAL_CALL QtPlayer::disposing()
 279 {
 280     osl::MutexGuard aGuard(m_aMutex);
 281     stop();
 282     QtPlayer_BASE::disposing();
 283 }
 284
 285 QtPlayer::~QtPlayer()
 286 {
 287     // ensure output objects get deleted as QMediaPlayer doesn't take ownership of them
 288     std::unique_ptr<QObject> xVideoWidget(m_xMediaPlayer->videoOutput());
 289     std::unique_ptr<QAudioOutput> xAudioOutput(m_xMediaPlayer->audioOutput());
 290     m_xMediaPlayer.reset();
 291 }
 292
 293 bool QtPlayer::isReadyToPlay()
 294 {
 295     assert(m_xMediaPlayer);
 296     QMediaPlayer::MediaStatus eStatus = m_xMediaPlayer->mediaStatus();
 297     return eStatus == QMediaPlayer::BufferingMedia || eStatus == QMediaPlayer::BufferedMedia
 298            || eStatus == QMediaPlayer::LoadedMedia || eStatus == QMediaPlayer::EndOfMedia;
 299 }
 300
 301 void QtPlayer::installNotify()
 302 {
 303     connect(m_xMediaPlayer.get(), &QMediaPlayer::mediaStatusChanged, this,
 304             &QtPlayer::notifyIfReady);
 305 }
 306
 307 void QtPlayer::uninstallNotify()
 308 {
 309     disconnect(m_xMediaPlayer.get(), &QMediaPlayer::mediaStatusChanged, this,
 310                &QtPlayer::notifyIfReady);
 311 }
 312
 313 void QtPlayer::notifyIfReady(QMediaPlayer::MediaStatus)
 314 {
 315     if (isReadyToPlay())
 316     {
 317         rtl::Reference<QtPlayer> xThis(this);
 318         xThis->notifyListeners();
 319         xThis->uninstallNotify();
 320     }
 321 }
 322
 323 void QtPlayer::createMediaPlayerWidget()
 324 {
 325     assert(m_xMediaPlayer);
 326     assert(m_xMediaPlayer->mediaStatus() != QMediaPlayer::LoadingMedia
 327            && "Media is still loading, detecting video availability not possible.");
 328
 329     assert(m_pMediaWidgetParent && "Parent for media widget not set");
 330
 331     // if media contains video, show the video output,
 332     // otherwise show an audio icon as a placeholder
 333     QWidget* pWidget;
 334     if (m_xMediaPlayer->hasVideo())
 335     {
 336         QVideoWidget* pVideoWidget = new QVideoWidget(m_pMediaWidgetParent);
 337         pVideoWidget->setAspectRatioMode(Qt::IgnoreAspectRatio);
 338
 339         assert(!m_xMediaPlayer->videoOutput() && "Video output already set.");
 340         m_xMediaPlayer->setVideoOutput(pVideoWidget);
 341
 342         pWidget = pVideoWidget;
 343     }
 344     else
 345     {
 346         QPixmap aAudioPixmap = loadQPixmapIcon(u"avmedia/res/avaudiologo.png"_ustr);
 347         aAudioPixmap
 348             = aAudioPixmap.scaled(QSize(m_aPlayerWidgetRect.Width, m_aPlayerWidgetRect.Height));
 349
 350         QLabel* pLabel = new QLabel;
 351         pLabel->setPixmap(aAudioPixmap);
 352         pWidget = pLabel;
 353     }
 354
 355     assert(pWidget);
 356     pWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 357
 358     // retrieve the layout (which is set in the QtObjectWidget ctor)
 359     QLayout* pLayout = m_pMediaWidgetParent->layout();
 360     assert(pLayout);
 361     assert(pLayout->count() == 0 && "Layout already has a widget set");
 362     pLayout->addWidget(pWidget);
 363 }
 364
 365 void QtPlayer::notifyListeners()
 366 {
 367     comphelper::OInterfaceContainerHelper2* pContainer
 368         = m_lListener.getContainer(cppu::UnoType<css::media::XPlayerListener>::get());
 369     if (!pContainer)
 370         return;
 371
 372     css::lang::EventObject aEvent;
 373     aEvent.Source = getXWeak();
 374
 375     comphelper::OInterfaceIteratorHelper2 pIterator(*pContainer);
 376     while (pIterator.hasMoreElements())
 377     {
 378         css::uno::Reference<css::media::XPlayerListener> xListener(
 379             static_cast<css::media::XPlayerListener*>(pIterator.next()));
 380         xListener->preferredPlayerWindowSizeAvailable(aEvent);
 381     }
 382 }
 383
 384 } // namespace
 385
 386 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */