KisPlaybackEngineQT Class Reference

The KisPlaybackEngineQT class is an implementation of KisPlaybackEngine that drives animation playback using simple Qt functionality alone. More...

#include <KisPlaybackEngineQT.h>

Inheritance diagram for KisPlaybackEngineQT:

Classes
struct	Private

Public Member Functions
boost::optional< int64_t >	activeFramesPerSecond () const
bool	isMute () override
	KisPlaybackEngineQT (QObject *parent=nullptr)
PlaybackStats	playbackStatistics () const override
void	seek (int frameIndex, SeekOptionFlags flags=SEEK_FINALIZE|SEEK_PUSH_AUDIO) override
void	setDropFramesMode (bool value) override
void	setMute (bool) override
bool	supportsAudio () override
bool	supportsVariablePlaybackSpeed () override
	~KisPlaybackEngineQT ()
Public Member Functions inherited from KisPlaybackEngine
	KisPlaybackEngine (QObject *parent=nullptr)
	~KisPlaybackEngine ()
Public Member Functions inherited from KoCanvasObserverBase
	KoCanvasObserverBase ()
KoCanvasBase *	observedCanvas () const
virtual QString	observerName ()
void	setObservedCanvas (KoCanvasBase *canvas)
void	unsetObservedCanvas ()
virtual	~KoCanvasObserverBase ()

Protected Slots
void	throttledDriverCallback ()
	throttledDriverCallback handles signals from the internal driver that drives playback within this engine. It will either increment frame time, wrapping within bounds, and communicate with KisFrameDisplayProxy or use the driver's desired time to control which frame is visible...
Protected Slots inherited from KisPlaybackEngine

Protected Member Functions
void	setCanvas (KoCanvasBase *canvas) override
void	unsetCanvas () override
Protected Member Functions inherited from KisPlaybackEngine
class KisCanvas2 *	activeCanvas () const
int	frameWrap (int frame, int startFrame, int endFrame)

Private Attributes
QScopedPointer< Private >	m_d

Additional Inherited Members
Public Slots inherited from KisPlaybackEngine
bool	dropFrames () const
virtual void	firstFrame ()
virtual void	lastFrame ()
virtual void	nextFrame ()
virtual void	nextKeyframe ()
virtual void	nextMatchingKeyframe ()
virtual void	nextUnfilteredKeyframe ()
virtual void	pause ()
virtual void	play ()
virtual void	playPause ()
virtual void	previousFrame ()
virtual void	previousKeyframe ()
virtual void	previousMatchingKeyframe ()
	previousMatchingKeyframe && nextMatchingKeyframe Navigate to the next keyframe that has the same color-label as the current keyframe. Useful to quickly navigate to user-specified 'similar' keyframes. E.g. Contact points in an animation might have a specific color to specify importance and be quickly swapped between.
virtual void	previousUnfilteredKeyframe ()
	previousUnfilteredKeyframe && nextUnfilteredKeyframe Navigate to keyframes based on the current onion skin filtration. This lets users easily navigate to the next visible "onion-skinned" keyframe on the active layer.
virtual void	stop ()
Signals inherited from KisPlaybackEngine
void	sigDropFramesModeChanged (bool value)

Detailed Description

The KisPlaybackEngineQT class is an implementation of KisPlaybackEngine that drives animation playback using simple Qt functionality alone.

As of right now, this playback engine is used as a fallback for when KisPlaybackEngineMLT is unavailable, invalid, or otherwise unwanted.

Definition at line 27 of file KisPlaybackEngineQT.h.

Constructor & Destructor Documentation

KisPlaybackEngineQT()

KisPlaybackEngineQT::KisPlaybackEngineQT ( QObject * parent = nullptr )

explicit

Definition at line 167 of file KisPlaybackEngineQT.cpp.

    : KisPlaybackEngine(parent)
    , m_d(new Private())
{
}

~KisPlaybackEngineQT()

KisPlaybackEngineQT::~KisPlaybackEngineQT

(

)

Definition at line 173 of file KisPlaybackEngineQT.cpp.

{
}

Member Function Documentation

activeFramesPerSecond()

boost::optional< int64_t > KisPlaybackEngineQT::activeFramesPerSecond

(

)

const

Definition at line 201 of file KisPlaybackEngineQT.cpp.

{
    if (activeCanvas()) {
        return activeCanvas()->image()->animationInterface()->framerate();
    } else {
        return boost::none;
    }
}

References KisPlaybackEngine::activeCanvas(), KisImage::animationInterface(), KisImageAnimationInterface::framerate(), and KisCanvas2::image().

isMute()

bool KisPlaybackEngineQT::isMute ( )

inlineoverridevirtual

Implements KisPlaybackEngine.

Definition at line 38 of file KisPlaybackEngineQT.h.

{ return true; }

playbackStatistics()

KisPlaybackEngine::PlaybackStats KisPlaybackEngineQT::playbackStatistics ( ) const

overridevirtual

Implements KisPlaybackEngine.

Definition at line 210 of file KisPlaybackEngineQT.cpp.

{
    KisPlaybackEngine::PlaybackStats stats;
 
    if (activeCanvas()->animationState()->playbackState() == PLAYING) {
        const int droppedFrames = m_d->measure.droppedFramesStat.rollingSum();
        const int totalFrames =
            m_d->measure.droppedFramesStat.rollingCount() +
            droppedFrames;
 
        stats.droppedFramesPortion = qreal(droppedFrames) / totalFrames;
        stats.expectedFps = qreal(activeFramesPerSecond().get_value_or(24)) * m_d->driver->speed();
 
        const qreal avgTimePerFrame = m_d->measure.averageTimePerFrame.rollingMeanSafe();
        stats.realFps = !qFuzzyIsNull(avgTimePerFrame) ? 1000.0 / avgTimePerFrame : 0.0;
    }
 
    return stats;
}

References KisPlaybackEngine::activeCanvas(), activeFramesPerSecond(), KisPlaybackEngine::PlaybackStats::droppedFramesPortion, KisPlaybackEngine::PlaybackStats::expectedFps, m_d, PLAYING, qFuzzyIsNull(), and KisPlaybackEngine::PlaybackStats::realFps.

seek()

void KisPlaybackEngineQT::seek ( int frameIndex, SeekOptionFlags flags = SEEK_FINALIZE | SEEK_PUSH_AUDIO )

overridevirtual

Implements KisPlaybackEngine.

Definition at line 177 of file KisPlaybackEngineQT.cpp.

{
    if (!activeCanvas())
        return;
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(activeCanvas()->animationState());
 
    KisFrameDisplayProxy* displayProxy = activeCanvas()->animationState()->displayProxy();
    KIS_SAFE_ASSERT_RECOVER_RETURN(displayProxy);
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(frameIndex >= 0);
 
    if (displayProxy->activeFrame() != frameIndex || flags & SEEK_FINALIZE) {
        displayProxy->displayFrame(frameIndex, flags & SEEK_FINALIZE);
    }
}

References KisPlaybackEngine::activeCanvas(), KisFrameDisplayProxy::activeFrame(), KisCanvas2::animationState(), KisFrameDisplayProxy::displayFrame(), KisCanvasAnimationState::displayProxy(), KIS_SAFE_ASSERT_RECOVER_RETURN, and SEEK_FINALIZE.

setCanvas()

void KisPlaybackEngineQT::setCanvas ( KoCanvasBase * canvas )

overrideprotectedvirtual

Reimplemented from KisPlaybackEngine.

Definition at line 286 of file KisPlaybackEngineQT.cpp.

{
    KisCanvas2* canvas = dynamic_cast<KisCanvas2*>(p_canvas);
 
    struct StopAndResume {
        StopAndResume(KisPlaybackEngineQT* p_self)
            : m_self(p_self) {
            KIS_SAFE_ASSERT_RECOVER_RETURN(m_self->m_d->driver);
 
            m_self->m_d->driver->setPlaybackState(PlaybackState::STOPPED);
        }
 
        ~StopAndResume() {
            KIS_SAFE_ASSERT_RECOVER_RETURN(m_self->m_d->driver);
 
            if (m_self->activeCanvas()) {
                m_self->m_d->driver->setPlaybackState(m_self->activeCanvas()->animationState()->playbackState());
            }
        }
 
    private:
        KisPlaybackEngineQT* m_self;
    };
 
    if (activeCanvas() == canvas) {
        return;
    }
 
    if (activeCanvas()) {
        KisCanvasAnimationState* animationState = activeCanvas()->animationState();
 
        KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->driver);
 
        // Disconnect internal..
        m_d->driver.data()->disconnect(this);
 
        { // Disconnect old Image Anim Interface, prepare for new one..
            auto image = activeCanvas()->image();
            KisImageAnimationInterface* aniInterface = image ? image->animationInterface() : nullptr;
            if (aniInterface) {
                this->disconnect(image->animationInterface());
                image->animationInterface()->disconnect(this);
            }
        }
 
        { // Disconnect old display proxy, prepare for new one.
            KisFrameDisplayProxy* displayProxy = animationState->displayProxy();
 
            if (displayProxy) {
                displayProxy->disconnect(this);
            }
        }
 
        { // Disconnect old animation state, prepare for new one..
            if (animationState) {
                this->disconnect(animationState);
                animationState->disconnect(this);
            }
        }
    }
 
    StopAndResume stopResume(this);
 
    KisPlaybackEngine::setCanvas(canvas);
 
    if (activeCanvas()) {
        KisCanvasAnimationState* animationState = activeCanvas()->animationState();
        KIS_ASSERT(animationState);
 
        KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->driver);
 
        { // Animation State Connections
            connect(animationState, &KisCanvasAnimationState::sigPlaybackStateChanged, this, [this](PlaybackState state){
                KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->driver);
 
                if (state == PLAYING) {
                    m_d->measure.reset();
                }
 
                m_d->driver->setPlaybackState(state);
            });
 
            connect(animationState, &KisCanvasAnimationState::sigPlaybackSpeedChanged, this, [this](qreal value){
                KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->driver);
                m_d->driver->setSpeed(value);
            });
            m_d->driver->setSpeed(animationState->playbackSpeed());
        }
 
        { // Display proxy connections
            KisFrameDisplayProxy* displayProxy = animationState->displayProxy();
            KIS_ASSERT(displayProxy);
            connect(displayProxy, &KisFrameDisplayProxy::sigFrameDisplayRefreshed, this, [this](){
                m_d->measure.waitingForFrame = false;
            });
 
            connect(displayProxy, &KisFrameDisplayProxy::sigFrameRefreshSkipped, this, [this](){
                m_d->measure.waitingForFrame = false;
            });
        }
 
 
        {   // Animation Interface Connections
            auto image = activeCanvas()->image();
            KIS_ASSERT(image);
            KisImageAnimationInterface* aniInterface = image->animationInterface();
            KIS_ASSERT(aniInterface);
 
            connect(aniInterface, &KisImageAnimationInterface::sigFramerateChanged, this, [this](){
                if (!activeCanvas())
                    return;
 
                KisImageWSP img = activeCanvas()->image();
                KIS_SAFE_ASSERT_RECOVER_RETURN(img);
                KisImageAnimationInterface* aniInterface = img->animationInterface();
                KIS_SAFE_ASSERT_RECOVER_RETURN(aniInterface);
 
                m_d->driver->setFramerate(aniInterface->framerate());
            });
 
            m_d->driver->setFramerate(aniInterface->framerate());
        }
 
        // Internal connections
        connect(m_d->driver.data(), SIGNAL(throttledShowFrame()), this, SLOT(throttledDriverCallback()));
 
    }
}

References KisPlaybackEngine::activeCanvas(), KisImage::animationInterface(), KisCanvas2::animationState(), connect(), KisCanvasAnimationState::displayProxy(), KisImageAnimationInterface::framerate(), KisCanvas2::image(), KIS_ASSERT, KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, KisCanvasAnimationState::playbackSpeed(), PLAYING, KisPlaybackEngine::setCanvas(), KisFrameDisplayProxy::sigFrameDisplayRefreshed(), KisImageAnimationInterface::sigFramerateChanged(), KisFrameDisplayProxy::sigFrameRefreshSkipped(), KisCanvasAnimationState::sigPlaybackSpeedChanged(), KisCanvasAnimationState::sigPlaybackStateChanged(), STOPPED, throttledDriverCallback(), and value().

setDropFramesMode()

void KisPlaybackEngineQT::setDropFramesMode ( bool value )

overridevirtual

Reimplemented from KisPlaybackEngine.

Definition at line 194 of file KisPlaybackEngineQT.cpp.

{
    KisPlaybackEngine::setDropFramesMode(value);
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->driver);
    m_d->driver->setDropFrames(value);
}

References KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, KisPlaybackEngine::setDropFramesMode(), and value().

setMute()

void KisPlaybackEngineQT::setMute ( bool )

inlineoverridevirtual

Implements KisPlaybackEngine.

Definition at line 37 of file KisPlaybackEngineQT.h.

{}

supportsAudio()

bool KisPlaybackEngineQT::supportsAudio ( )

inlineoverridevirtual

Implements KisPlaybackEngine.

Definition at line 40 of file KisPlaybackEngineQT.h.

{return false;}

supportsVariablePlaybackSpeed()

bool KisPlaybackEngineQT::supportsVariablePlaybackSpeed ( )

inlineoverridevirtual

Implements KisPlaybackEngine.

Definition at line 41 of file KisPlaybackEngineQT.h.

{ return true; }

throttledDriverCallback

void KisPlaybackEngineQT::throttledDriverCallback ( )

protectedslot

throttledDriverCallback handles signals from the internal driver that drives playback within this engine. It will either increment frame time, wrapping within bounds, and communicate with KisFrameDisplayProxy or use the driver's desired time to control which frame is visible...

Definition at line 230 of file KisPlaybackEngineQT.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->driver);
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(activeCanvas()->animationState());
    KIS_SAFE_ASSERT_RECOVER_RETURN(activeCanvas()->animationState()->playbackState() == PLAYING);
 
    KisFrameDisplayProxy* displayProxy = activeCanvas()->animationState()->displayProxy();
    KIS_SAFE_ASSERT_RECOVER_RETURN(displayProxy);
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(activeCanvas()->image());
    KisImageAnimationInterface *animInterface = activeCanvas()->image()->animationInterface();
    KIS_SAFE_ASSERT_RECOVER_RETURN(animInterface);
 
    // If we're waiting for each frame, then we delay our callback.
    if (m_d->measure.waitingForFrame) {
        // Without drop frames on, we need to factor out time that we're waiting
        // for a frame from our time
        return;
    }
 
    const int currentFrame = displayProxy->activeFrame();
    const int startFrame = animInterface->activePlaybackRange().start();
    const int endFrame = animInterface->activePlaybackRange().end();
 
    const int timeSinceLastFrame =  m_d->measure.timeSinceLastFrame.restart();
    const int timePerFrame = qRound(1000.0 / qreal(activeFramesPerSecond().get_value_or(24)) / m_d->driver->speed());
    m_d->measure.averageTimePerFrame(timeSinceLastFrame);
 
 
    // Drop frames logic...
    int extraFrames = 0;
    if (m_d->driver->dropFrames()) {
        const int offset = timeSinceLastFrame - timePerFrame;
        extraFrames = qMax(0, offset) / timePerFrame;
    }
 
    m_d->measure.droppedFramesStat(extraFrames);
 
    { // just advance the frame ourselves based on the displayProxy's active frame.
        int targetFrame = currentFrame + 1 + extraFrames;
 
        targetFrame = frameWrap(targetFrame, startFrame, endFrame);
 
        if (currentFrame != targetFrame) {
            // We only wait when drop frames is enabled.
            m_d->measure.waitingForFrame = !m_d->driver->dropFrames();
 
            bool neededRefresh = displayProxy->displayFrame(targetFrame, false);
 
            // If we didn't need to refresh, we just continue as usual.
            m_d->measure.waitingForFrame &= neededRefresh;
        }
    }
}

References KisPlaybackEngine::activeCanvas(), KisFrameDisplayProxy::activeFrame(), activeFramesPerSecond(), KisImageAnimationInterface::activePlaybackRange(), KisImage::animationInterface(), KisCanvas2::animationState(), KisFrameDisplayProxy::displayFrame(), KisCanvasAnimationState::displayProxy(), KisTimeSpan::end(), KisPlaybackEngine::frameWrap(), KisCanvas2::image(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, PLAYING, and KisTimeSpan::start().

unsetCanvas()

void KisPlaybackEngineQT::unsetCanvas ( )

overrideprotectedvirtual

Reimplemented from KisPlaybackEngine.

Definition at line 415 of file KisPlaybackEngineQT.cpp.

{
    setCanvas(nullptr);
}

References setCanvas().

Member Data Documentation

m_d

QScopedPointer<Private> KisPlaybackEngineQT::m_d

private

Definition at line 65 of file KisPlaybackEngineQT.h.

---

The documentation for this class was generated from the following files:

• libs/ui/KisPlaybackEngineQT.h
• libs/ui/KisPlaybackEngineQT.cpp