git.sesse.net Git - kdenlive/blob - src/abstractscopewidget.h

   1 /***************************************************************************
   2  *   Copyright (C) 2010 by Simon Andreas Eugster (simon.eu@gmail.com)      *
   3  *   This file is part of kdenlive. See www.kdenlive.org.                  *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  ***************************************************************************/
  10
  11 /**
  12   This abstract widget is a proof that abstract things sometimes *are* useful.
  13
  14   The widget expects three layers which
  15   * Will be painted on top of each other on each update
  16   * Are rendered in a separate thread so that the UI is not blocked
  17   * Are rendered only if necessary (e.g., if a layer does not depend
  18     on input images, it will not be re-rendered for incoming frames)
  19
  20   The layer order is as follows:
  21      _____________________
  22     /                     \
  23    /      HUD Layer        \
  24   /                         \
  25   ---------------------------
  26      _____________________
  27     /                     \
  28    /     Scope Layer       \
  29   /                         \
  30   ---------------------------
  31      _____________________
  32     /                     \
  33    /   Background Layer    \
  34   /                         \
  35   ---------------------------
  36
  37   Colors of Scope Widgets are defined in here (and thus don't need to be
  38   re-defined in the implementation of the widget's .ui file).
  39
  40   The custom context menu already contains entries, like for enabling auto-
  41   refresh. It can certainly be extended in the implementation of the widget.
  42
  43   Note: Widgets deriving from this class should connect slotActiveMonitorChanged
  44   to the appropriate signal.
  45
  46   If you intend to write an own widget inheriting from this one, please read
  47   the comments on the unimplemented methods carefully. They are not only here
  48   for optical amusement, but also contain important information.
  49  */
  50
  51 #ifndef ABSTRACTSCOPEWIDGET_H
  52 #define ABSTRACTSCOPEWIDGET_H
  53
  54 #include <QtCore>
  55 #include <QWidget>
  56
  57 class QMenu;
  58
  59 class Monitor;
  60 class Render;
  61
  62 class AbstractScopeWidget : public QWidget
  63 {
  64     Q_OBJECT
  65
  66 public:
  67     AbstractScopeWidget(Monitor *projMonitor, Monitor *clipMonitor, QWidget *parent = 0);
  68     virtual ~AbstractScopeWidget(); // Must be virtual because of inheritance, to avoid memory leaks
  69     QPalette m_scopePalette;
  70
  71     ///// Unimplemented /////
  72
  73     virtual QString widgetName() const = 0;
  74
  75 protected:
  76     ///// Variables /////
  77
  78     Monitor *m_projMonitor;
  79     Monitor *m_clipMonitor;
  80     Render *m_activeRender;
  81
  82
  83     /** The context menu. Feel free to add new entries in your implementation. */
  84     QMenu *m_menu;
  85
  86     /** Enables auto refreshing of the scope.
  87         This is when a new frame is shown on the active monitor.
  88         Resize events always force a recalculation. */
  89     QAction *m_aAutoRefresh;
  90
  91     /** Realtime rendering. Should be disabled if it is not supported.
  92         Use the accelerationFactor variable passed to the render functions as a hint of
  93         how many times faster the scope should be calculated. */
  94     QAction *m_aRealtime;
  95
  96
  97     /** Offset from the widget's borders */
  98     const uchar offset;
  99
 100     /** The rect on the widget we're painting in. */
 101     QRect m_scopeRect;
 102
 103     /** Images storing the calculated layers. Will be used on repaint events. */
 104     QImage m_imgHUD;
 105     QImage m_imgScope;
 106     QImage m_imgBackground;
 107
 108     /** The acceleration factors can be accessed also by other renderer tasks,
 109         e.g. to display the scope's acceleration factor in the HUD renderer. */
 110     int m_accelFactorHUD;
 111     int m_accelFactorScope;
 112     int m_accelFactorBackground;
 113
 114
 115     ///// Unimplemented Methods /////
 116
 117     /** Where on the widget we can paint in.
 118         May also update other variables that depend on the widget's size.  */
 119     virtual QRect scopeRect() = 0;
 120
 121     /** @brief HUD renderer. Must emit signalHUDRenderingFinished(). @see renderScope */
 122     virtual QImage renderHUD(uint accelerationFactor) = 0;
 123     /** @brief Scope renderer. Must emit signalScopeRenderingFinished()
 124         when calculation has finished, to allow multi-threading.
 125         accelerationFactor hints how much faster than usual the calculation should be accomplished, if possible. */
 126     virtual QImage renderScope(uint accelerationFactor) = 0;
 127     /** @brief Background renderer. Must emit signalBackgroundRenderingFinished(). @see renderScope */
 128     virtual QImage renderBackground(uint accelerationFactor) = 0;
 129
 130     /** Must return true if the HUD layer depends on the input monitor.
 131         If it does not, then it does not need to be re-calculated when
 132         a new frame from the monitor is incoming. */
 133     virtual bool isHUDDependingOnInput() const = 0;
 134     /** @see isHUDDependingOnInput() */
 135     virtual bool isScopeDependingOnInput() const = 0;
 136     /** @see isHUDDependingOnInput() */
 137     virtual bool isBackgroundDependingOnInput() const = 0;
 138
 139     ///// Can be reimplemented /////
 140     /** Calculates the acceleration factor to be used by the render thread.
 141         This method can be refined in the subclass if required. */
 142     virtual uint calculateAccelFactorHUD(uint oldMseconds, uint oldFactor);
 143     virtual uint calculateAccelFactorScope(uint oldMseconds, uint oldFactor);
 144     virtual uint calculateAccelFactorBackground(uint oldMseconds, uint oldFactor);
 145
 146     ///// Reimplemented /////
 147
 148     void mouseReleaseEvent(QMouseEvent *);
 149     void paintEvent(QPaintEvent *);
 150     void raise();
 151     void resizeEvent(QResizeEvent *);
 152
 153 protected slots:
 154     /** Forces an update of all layers. */
 155     void forceUpdate();
 156     void forceUpdateHUD();
 157     void forceUpdateScope();
 158     void forceUpdateBackground();
 159     void slotAutoRefreshToggled(bool);
 160
 161 signals:
 162     /** mseconds represent the time taken for the calculation,
 163         accelerationFactor the acceleration factor that has been used. */
 164     void signalHUDRenderingFinished(uint mseconds, uint accelerationFactor);
 165     void signalScopeRenderingFinished(uint mseconds, uint accelerationFactor);
 166     void signalBackgroundRenderingFinished(uint mseconds, uint accelerationFactor);
 167
 168 private:
 169
 170     /** Counts the number of frames that have been rendered in the active monitor.
 171       The frame number will be reset when the calculation starts for the current frame. */
 172     QAtomicInt m_newHUDFrames;
 173     QAtomicInt m_newScopeFrames;
 174     QAtomicInt m_newBackgroundFrames;
 175
 176     /** Counts the number of updates that, unlike new frames, force a recalculation
 177       of the scope, like for example a resize event. */
 178     QAtomicInt m_newHUDUpdates;
 179     QAtomicInt m_newScopeUpdates;
 180     QAtomicInt m_newBackgroundUpdates;
 181
 182     /** The semaphores ensure that the QFutures for the HUD/Scope/Background threads cannot
 183       be assigned a new thread while it is still running. (Could cause deadlocks and other
 184       nasty things known from parallelism. */
 185     QSemaphore m_semaphoreHUD;
 186     QSemaphore m_semaphoreScope;
 187     QSemaphore m_semaphoreBackground;
 188
 189     QFuture<QImage> m_threadHUD;
 190     QFuture<QImage> m_threadScope;
 191     QFuture<QImage> m_threadBackground;
 192
 193     bool initialDimensionUpdateDone;
 194     void prodHUDThread();
 195     void prodScopeThread();
 196     void prodBackgroundThread();
 197
 198
 199 private slots:
 200     /** @brief Must be called when the active monitor has shown a new frame.
 201       This slot must be connected in the implementing class, it is *not*
 202       done in this abstract class. */
 203     void slotActiveMonitorChanged(bool isClipMonitor);
 204     void customContextMenuRequested(const QPoint &pos);
 205     void slotRenderZoneUpdated();
 206     void slotHUDRenderingFinished(uint mseconds, uint accelerationFactor);
 207     void slotScopeRenderingFinished(uint mseconds, uint accelerationFactor);
 208     void slotBackgroundRenderingFinished(uint mseconds, uint accelerationFactor);
 209
 210     /** Resets the acceleration factors to 1 when realtime rendering is disabled. */
 211     void slotResetRealtimeFactor(bool realtimeChecked);
 212
 213 };
 214
 215 #endif // ABSTRACTSCOPEWIDGET_H