File indexing completed on 2024-05-12 04:44:38

 /*
     Copyright (C) 2007-2008 Tanguy Krotoff <tkrotoff@gmail.com>
     Copyright (C) 2008 Lukas Durfina <lukas.durfina@gmail.com>
     Copyright (C) 2009 Fathi Boudra <fabo@kde.org>
     Copyright (C) 2009-2011 vlc-phonon AUTHORS <kde-multimedia@kde.org>
     Copyright (C) 2011-2021 Harald Sitter <sitter@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) any later version.
 
     This library 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
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "videowidget.h"
 
 #include <QGuiApplication>
 #include <QPainter>
 #include <QPaintEvent>
 
 #include <vlc/vlc.h>
 
 #include "utils/debug.h"
 #include "mediaobject.h"
 #include "media.h"
 
 #include "video/videomemorystream.h"
 
 namespace Phonon {
 namespace VLC {
 
 #define DEFAULT_QSIZE QSize(320, 240)
 
 class SurfacePainter : public VideoMemoryStream
 {
 public:
     void handlePaint(QPaintEvent *event)
     {
         // Mind that locking here is still faster than making this lockfree by
         // dispatching QEvents.
         // Plus VLC can actually skip frames as necessary.
         QMutexLocker lock(&m_mutex);
         Q_UNUSED(event);
 
         if (m_frame.isNull()) {
             return;
         }
 
         QPainter painter(widget);
         // When using OpenGL for the QPaintEngine drawing the same QImage twice
         // does not actually result in a texture change for one reason or another.
         // So we simply create new images for every event. This is plenty cheap
         // as the QImage only points to the plane data (it can't even make it
         // properly shared as it does not know that the data belongs to a QBA).
         // TODO: investigate if this is still necessary. This was added for gwenview, but with Qt 5.15 the problem
         //   can't be produced.
         painter.drawImage(drawFrameRect(), QImage(m_frame));
         event->accept();
     }
 
     VideoWidget *widget;
 
 private:
     void *lockCallback(void **planes) override
     {
         m_mutex.lock();
         planes[0] = (void *) m_frame.bits();
         return 0;
     }
 
     void unlockCallback(void *picture,void *const *planes) override
     {
         Q_UNUSED(picture);
         Q_UNUSED(planes);
         m_mutex.unlock();
     }
 
     void displayCallback(void *picture) override
     {
         Q_UNUSED(picture);
         if (widget)
             widget->update();
     }
 
     unsigned formatCallback(char *chroma,
                                     unsigned *width, unsigned *height,
                                     unsigned *pitches,
                                     unsigned *lines) override
     {
         QMutexLocker lock(&m_mutex);
         // Surface rendering is a fallback system used when no efficient rendering implementation is available.
         // As such we only support RGB32 for simplicity reasons and this will almost always mean software scaling.
         // And since scaling is unavoidable anyway we take the canonical frame size and then scale it on our end via
         // QPainter, again, greater simplicity at likely no real extra cost since this is all super inefficient anyway.
         // Also, since aspect ratio can be change mid-playback by the user, doing the scaling on our end means we
         // don't need to restart the entire player to retrigger format calculation.
         // With all that in mind we simply use the canonical size and feed VLC the QImage's pitch and lines as
         // effectively the VLC vout is the QImage so its constraints matter.
 
         // per https://wiki.videolan.org/Hacker_Guide/Video_Filters/#Pitch.2C_visible_pitch.2C_planes_et_al.
         // it would seem that we can use either real or visible pitches and lines as VLC generally will iterate the
         // smallest value when moving data between two entities. i.e. since QImage will at most paint NxM anyway,
         // we may just go with its values as calculating the real pitch/line of the VLC picture_t for RV32 wouldn't
         // change the maximum pitch/lines we can paint on the output side.
 
         qstrcpy(chroma, "RV32");
         m_frame = QImage(*width, *height, QImage::Format_RGB32);
         Q_ASSERT(!m_frame.isNull()); // ctor may construct null if allocation fails
         m_frame.fill(0);
         pitches[0] = m_frame.bytesPerLine();
         lines[0] = m_frame.sizeInBytes() / m_frame.bytesPerLine();
 
         return  m_frame.sizeInBytes();
     }
 
     void formatCleanUpCallback() override
     {
         // Lazy delete the object to avoid callbacks from VLC after deletion.
         if (!widget) {
             // The widget member is set to null by the widget destructor, so when this condition is true the
             // widget had already been destroyed and we can't possibly receive a paint event anymore, meaning
             // we need no lock here. If it were any other way we'd have trouble with synchronizing deletion
             // without deleting a locked mutex.
             delete this;
         }
     }
 
     QRect scaleToAspect(QRect srcRect, int w, int h) const
     {
         float width = srcRect.width();
         float height = srcRect.width() * (float(h) / float(w));
         if (height > srcRect.height()) {
             height = srcRect.height();
             width = srcRect.height() * (float(w) / float(h));
         }
         return QRect(0, 0, (int)width, (int)height);
     }
 
     QRect drawFrameRect() const
     {
         QRect widgetRect = widget->rect();
         QRect drawFrameRect;
         switch (widget->aspectRatio()) {
         case Phonon::VideoWidget::AspectRatioWidget:
             drawFrameRect = widgetRect;
             // No more calculations needed.
             return drawFrameRect;
         case Phonon::VideoWidget::AspectRatio4_3:
             drawFrameRect = scaleToAspect(widgetRect, 4, 3);
             break;
         case Phonon::VideoWidget::AspectRatio16_9:
             drawFrameRect = scaleToAspect(widgetRect, 16, 9);
             break;
         case Phonon::VideoWidget::AspectRatioAuto:
             drawFrameRect = QRect(0, 0, m_frame.width(), m_frame.height());
             break;
         }
 
         // Scale m_drawFrameRect to fill the widget
         // without breaking aspect:
         float widgetWidth = widgetRect.width();
         float widgetHeight = widgetRect.height();
         float frameWidth = widgetWidth;
         float frameHeight = drawFrameRect.height() * float(widgetWidth) / float(drawFrameRect.width());
 
         switch (widget->scaleMode()) {
         case Phonon::VideoWidget::ScaleAndCrop:
             if (frameHeight < widgetHeight) {
                 frameWidth *= float(widgetHeight) / float(frameHeight);
                 frameHeight = widgetHeight;
             }
             break;
         case Phonon::VideoWidget::FitInView:
             if (frameHeight > widgetHeight) {
                 frameWidth *= float(widgetHeight) / float(frameHeight);
                 frameHeight = widgetHeight;
             }
             break;
         }
         drawFrameRect.setSize(QSize(int(frameWidth), int(frameHeight)));
         drawFrameRect.moveTo(int((widgetWidth - frameWidth) / 2.0f),
                                int((widgetHeight - frameHeight) / 2.0f));
         return drawFrameRect;
     }
 
     // Could ReadWriteLock two frames so VLC can write while we paint.
     QImage m_frame;
     QMutex m_mutex;
 };
 
 VideoWidget::VideoWidget(QWidget *parent) :
     BaseWidget(parent),
     SinkNode(),
     m_videoSize(DEFAULT_QSIZE),
     m_aspectRatio(Phonon::VideoWidget::AspectRatioAuto),
     m_scaleMode(Phonon::VideoWidget::FitInView),
     m_filterAdjustActivated(false),
     m_brightness(0.0),
     m_contrast(0.0),
     m_hue(0.0),
     m_saturation(0.0),
     m_surfacePainter(0)
 {
     // We want background painting so Qt autofills with black.
     setAttribute(Qt::WA_NoSystemBackground, false);
 
     // Required for dvdnav
 #ifdef __GNUC__
 #warning dragonplayer munches on our mouse events, so clicking in a DVD menu does not work - vlc 1.2 where are thu?
 #endif // __GNUC__
     setMouseTracking(true);
 
     // setBackgroundColor
     QPalette p = palette();
     p.setColor(backgroundRole(), Qt::black);
     setPalette(p);
     setAutoFillBackground(true);
 }
 
 VideoWidget::~VideoWidget()
 {
     if (m_surfacePainter)
         m_surfacePainter->widget = 0; // Lazy delete
 }
 
 void VideoWidget::handleConnectToMediaObject(MediaObject *mediaObject)
 {
     connect(mediaObject, SIGNAL(hasVideoChanged(bool)),
             SLOT(updateVideoSize(bool)));
     connect(mediaObject, SIGNAL(hasVideoChanged(bool)),
             SLOT(processPendingAdjusts(bool)));
     connect(mediaObject, SIGNAL(currentSourceChanged(MediaSource)),
             SLOT(clearPendingAdjusts()));
 
     clearPendingAdjusts();
 }
 
 void VideoWidget::handleDisconnectFromMediaObject(MediaObject *mediaObject)
 {
     // Undo all connections or path creation->destruction->creation can cause
     // duplicated connections or getting signals from two different MediaObjects.
     disconnect(mediaObject, 0, this, 0);
 }
 
 void VideoWidget::handleAddToMedia(Media *media)
 {
     media->addOption(":video");
 
     if (!m_surfacePainter) {
 #if defined(Q_OS_MAC)
         m_player->setNsObject(cocoaView());
 #elif defined(Q_OS_UNIX)
         if (QGuiApplication::platformName().contains(QStringLiteral("xcb"), Qt::CaseInsensitive)) {
             m_player->setXWindow(winId());
         } else {
             enableSurfacePainter();
         }
 #elif defined(Q_OS_WIN)
         m_player->setHwnd((HWND)winId());
 #endif
     }
 }
 
 Phonon::VideoWidget::AspectRatio VideoWidget::aspectRatio() const
 {
     return m_aspectRatio;
 }
 
 void VideoWidget::setAspectRatio(Phonon::VideoWidget::AspectRatio aspect)
 {
     DEBUG_BLOCK;
     if (!m_player)
         return;
 
     m_aspectRatio = aspect;
 
     switch (m_aspectRatio) {
     // FIXME: find a way to implement aspectratiowidget, it is meant to scale
     // and stretch (i.e. scale to window without retaining aspect ratio).
     case Phonon::VideoWidget::AspectRatioAuto:
         m_player->setVideoAspectRatio(QByteArray());
         return;
     case Phonon::VideoWidget::AspectRatio4_3:
         m_player->setVideoAspectRatio("4:3");
         return;
     case Phonon::VideoWidget::AspectRatio16_9:
         m_player->setVideoAspectRatio("16:9");
         return;
     }
     warning() << "The aspect ratio" << aspect << "is not supported by Phonon VLC.";
 }
 
 Phonon::VideoWidget::ScaleMode VideoWidget::scaleMode() const
 {
     return m_scaleMode;
 }
 
 void VideoWidget::setScaleMode(Phonon::VideoWidget::ScaleMode scale)
 {
 #ifdef __GNUC__
 #warning OMG WTF
 #endif
     m_scaleMode = scale;
     switch (m_scaleMode) {
     }
     warning() << "The scale mode" << scale << "is not supported by Phonon VLC.";
 }
 
 qreal VideoWidget::brightness() const
 {
     return m_brightness;
 }
 
 void VideoWidget::setBrightness(qreal brightness)
 {
     DEBUG_BLOCK;
     if (!m_player) {
         return;
     }
     if (!enableFilterAdjust()) {
         // Add to pending adjusts
         m_pendingAdjusts.insert(QByteArray("setBrightness"), brightness);
         return;
     }
 
     // VLC operates within a 0.0 to 2.0 range for brightness.
     m_brightness = brightness;
     m_player->setVideoAdjust(libvlc_adjust_Brightness,
                              phononRangeToVlcRange(m_brightness, 2.0));
 }
 
 qreal VideoWidget::contrast() const
 {
     return m_contrast;
 }
 
 void VideoWidget::setContrast(qreal contrast)
 {
     DEBUG_BLOCK;
     if (!m_player) {
         return;
     }
     if (!enableFilterAdjust()) {
         // Add to pending adjusts
         m_pendingAdjusts.insert(QByteArray("setContrast"), contrast);
         return;
     }
 
     // VLC operates within a 0.0 to 2.0 range for contrast.
     m_contrast = contrast;
     m_player->setVideoAdjust(libvlc_adjust_Contrast, phononRangeToVlcRange(m_contrast, 2.0));
 }
 
 qreal VideoWidget::hue() const
 {
     return m_hue;
 }
 
 void VideoWidget::setHue(qreal hue)
 {
     DEBUG_BLOCK;
     if (!m_player) {
         return;
     }
     if (!enableFilterAdjust()) {
         // Add to pending adjusts
         m_pendingAdjusts.insert(QByteArray("setHue"), hue);
         return;
     }
 
     // VLC operates within a 0 to 360 range for hue.
     // Phonon operates on -1.0 to 1.0, so we need to consider 0 to 180 as
     // 0 to 1.0 and 180 to 360 as -1 to 0.0.
     //              360/0 (0)
     //                 ___
     //                /   \
     //    270 (-.25)  |   |  90 (.25)
     //                \___/
     //             180 (1/-1)
     // (-.25 is 360 minus 90 (vlcValue of .25).
     m_hue = hue;
     const int vlcValue = static_cast<int>(phononRangeToVlcRange(qAbs(hue), 180.0, false));
     int value = 0;
     if (hue >= 0)
         value = vlcValue;
     else
         value = 360.0 - vlcValue;
     m_player->setVideoAdjust(libvlc_adjust_Hue, value);
 }
 
 qreal VideoWidget::saturation() const
 {
     return m_saturation;
 }
 
 void VideoWidget::setSaturation(qreal saturation)
 {
     DEBUG_BLOCK;
     if (!m_player) {
         return;
     }
     if (!enableFilterAdjust()) {
         // Add to pending adjusts
         m_pendingAdjusts.insert(QByteArray("setSaturation"), saturation);
         return;
     }
 
     // VLC operates within a 0.0 to 3.0 range for saturation.
     m_saturation = saturation;
     m_player->setVideoAdjust(libvlc_adjust_Saturation,
                               phononRangeToVlcRange(m_saturation, 3.0));
 }
 
 QWidget *VideoWidget::widget()
 {
     return this;
 }
 
 QSize VideoWidget::sizeHint() const
 {
     return m_videoSize;
 }
 
 void VideoWidget::updateVideoSize(bool hasVideo)
 {
     if (hasVideo) {
         m_videoSize = m_player->videoSize();
         updateGeometry();
         update();
     } else
         m_videoSize = DEFAULT_QSIZE;
 }
 
 void VideoWidget::setVisible(bool visible)
 {
     if (window() && window()->testAttribute(Qt::WA_DontShowOnScreen) && !m_surfacePainter) {
         enableSurfacePainter();
     }
     QWidget::setVisible(visible);
 }
 
 void VideoWidget::processPendingAdjusts(bool videoAvailable)
 {
     if (!videoAvailable || !m_mediaObject || !m_mediaObject->hasVideo()) {
         return;
     }
 
     QHashIterator<QByteArray, qreal> it(m_pendingAdjusts);
     while (it.hasNext()) {
         it.next();
         QMetaObject::invokeMethod(this, it.key().constData(), Q_ARG(qreal, it.value()));
     }
     m_pendingAdjusts.clear();
 }
 
 void VideoWidget::clearPendingAdjusts()
 {
     m_pendingAdjusts.clear();
 }
 
 void VideoWidget::paintEvent(QPaintEvent *event)
 {
     Q_UNUSED(event);
     if (m_surfacePainter)
         m_surfacePainter->handlePaint(event);
 }
 
 bool VideoWidget::enableFilterAdjust(bool adjust)
 {
     DEBUG_BLOCK;
     // Need to check for MO here, because we can get called before a VOut is actually
     // around in which case we just ignore this.
     if (!m_mediaObject || !m_mediaObject->hasVideo()) {
         debug() << "no mo or no video!!!";
         return false;
     }
     if ((!m_filterAdjustActivated && adjust) ||
             (m_filterAdjustActivated && !adjust)) {
         debug() << "adjust: " << adjust;
         m_player->setVideoAdjust(libvlc_adjust_Enable, static_cast<int>(adjust));
         m_filterAdjustActivated = adjust;
     }
     return true;
 }
 
 float VideoWidget::phononRangeToVlcRange(qreal phononValue, float upperBoundary,
                                          bool shift)
 {
     // VLC operates on different ranges than Phonon. Phonon always uses a range of
     // -1:1 with 0 as the default value.
     // It is therefore necessary to convert between the two schemes using sophisticated magic.
     // First the incoming range is locked between -1..1, then depending on shift
     // either normalized to 0..2 or 0..1 and finally a new value is calculated
     // depending on the upperBoundary and the normalized range.
     float value = static_cast<float>(phononValue);
     float range = 2.0; // The default normalized range will be 0..2 = 2
 
     // Ensure valid range
     if (value < -1.0)
         value = -1.0;
     else if (value > 1.0)
         value = 1.0;
 
     if (shift)
         value += 1.0; // Shift into 0..2 range
     else {
         // Chop negative value; normalize to 0..1 = range 1
         if (value < 0.0)
             value = 0.0;
         range = 1.0;
     }
 
     return (value * (upperBoundary/range));
 }
 
 QImage VideoWidget::snapshot() const
 {
     DEBUG_BLOCK;
     if (m_player)
         return m_player->snapshot();
     else
         return QImage();
 }
 
 void VideoWidget::enableSurfacePainter()
 {
     if (m_surfacePainter) {
         return;
     }
 
     debug() << "ENABLING SURFACE PAINTING";
     m_surfacePainter = new SurfacePainter;
     m_surfacePainter->widget = this;
     m_surfacePainter->setCallbacks(m_player);
 }
 
 } // namespace VLC
 } // namespace Phonon