KisAsyncAnimationFramesSavingRenderer Class Reference

#include <KisAsyncAnimationFramesSavingRenderer.h>

Inheritance diagram for KisAsyncAnimationFramesSavingRenderer:

Classes
struct	Private

Signals
void	sigCancelRegenerationInternal (int frame, KisAsyncAnimationRendererBase::CancelReason cancelReason)
void	sigCompleteRegenerationInternal (int frame)
Signals inherited from KisAsyncAnimationRendererBase
void	sigFrameCancelled (int frame, KisAsyncAnimationRendererBase::CancelReason cancelReason)
void	sigFrameCompleted (int frame)

Public Member Functions
	KisAsyncAnimationFramesSavingRenderer (KisImageSP image, const QString &fileNamePrefix, const QString &fileNameSuffix, const QByteArray &outputMimeType, const KisTimeSpan &range, const int sequenceNumberingOffset, const bool onlyNeedsUniqueFrames, KisPropertiesConfigurationSP exportConfiguration)
	~KisAsyncAnimationFramesSavingRenderer ()
Public Member Functions inherited from KisAsyncAnimationRendererBase
bool	isActive () const
	KisAsyncAnimationRendererBase (QObject *parent=0)
void	startFrameRegeneration (KisImageSP image, int frame, const KisRegion &regionOfInterest, Flags flags, KisLockFrameGenerationLock &&frameGenerationLock)
void	startFrameRegeneration (KisImageSP image, int frame, Flags flags, KisLockFrameGenerationLock &&frameGenerationLock)
virtual	~KisAsyncAnimationRendererBase ()
Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Protected Member Functions
void	frameCancelledCallback (int frame, CancelReason cancelReason) override
	frameCancelledCallback is called when the rendering of the frame was cancelled.
void	frameCompletedCallback (int frame, const KisRegion &requestedRegion) override
	frameCompletedCallback is called by the renderer when a new frame becomes ready
Protected Member Functions inherited from KisAsyncAnimationRendererBase
virtual void	clearFrameRegenerationState (bool isCancelled)
KisImageSP	requestedImage () const

Private Attributes
const QScopedPointer< Private >	m_d

Additional Inherited Members
Public Types inherited from KisAsyncAnimationRendererBase
enum	CancelReason { UserCancelled = 0 , RenderingFailed , RenderingTimedOut }
enum	Flag { None = 0x0 , Cancellable = 0x1 }
Public Slots inherited from KisAsyncAnimationRendererBase
void	cancelCurrentFrameRendering (CancelReason cancelReason)
	cancels current rendering operation
Public Attributes inherited from KisAsyncAnimationRendererBase
KisSignalAutoConnectionsStore	imageRequestConnections
bool	isCancelled = false
QTimer	regenerationTimeout
int	requestedFrame = -1
KisImageSP	requestedImage
KisRegion	requestedRegion
Public Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame
Protected Slots inherited from KisAsyncAnimationRendererBase
void	notifyFrameCancelled (int frame, KisAsyncAnimationRendererBase::CancelReason cancelReason)
void	notifyFrameCompleted (int frame)

Detailed Description

Definition at line 15 of file KisAsyncAnimationFramesSavingRenderer.h.

Constructor & Destructor Documentation

KisAsyncAnimationFramesSavingRenderer()

KisAsyncAnimationFramesSavingRenderer::KisAsyncAnimationFramesSavingRenderer	(	KisImageSP	image,
		const QString &	fileNamePrefix,
		const QString &	fileNameSuffix,
		const QByteArray &	outputMimeType,
		const KisTimeSpan &	range,
		const int	sequenceNumberingOffset,
		const bool	onlyNeedsUniqueFrames,
		KisPropertiesConfigurationSP	exportConfiguration )

Definition at line 61 of file KisAsyncAnimationFramesSavingRenderer.cpp.

    : m_d(new Private(image, range, sequenceNumberingOffset, onlyNeedsUniqueFrames, exportConfiguration))
{
    m_d->filenamePrefix = fileNamePrefix;
    m_d->filenameSuffix = fileNameSuffix;
    m_d->outputMimeType = outputMimeType;
 
    connect(this, SIGNAL(sigCompleteRegenerationInternal(int)), SLOT(notifyFrameCompleted(int)));
    connect(this, SIGNAL(sigCancelRegenerationInternal(int, KisAsyncAnimationRendererBase::CancelReason)), SLOT(notifyFrameCancelled(int, KisAsyncAnimationRendererBase::CancelReason)));
}

References connect(), m_d, KisAsyncAnimationRendererBase::notifyFrameCancelled(), KisAsyncAnimationRendererBase::notifyFrameCompleted(), sigCancelRegenerationInternal(), and sigCompleteRegenerationInternal().

~KisAsyncAnimationFramesSavingRenderer()

KisAsyncAnimationFramesSavingRenderer::~KisAsyncAnimationFramesSavingRenderer

(

)

Definition at line 82 of file KisAsyncAnimationFramesSavingRenderer.cpp.

{
}

Member Function Documentation

frameCancelledCallback()

void KisAsyncAnimationFramesSavingRenderer::frameCancelledCallback ( int frame, CancelReason cancelReason )

overrideprotectedvirtual

frameCancelledCallback is called when the rendering of the frame was cancelled.

The rendering of the frame can be either cancelled by the image itself or by receiving a timeout signal (10 seconds).

NOTE: the slot is called in the GUI thread. Don't forget to call notifyFrameCancelled() in he end of your call.

Implements KisAsyncAnimationRendererBase.

Definition at line 136 of file KisAsyncAnimationFramesSavingRenderer.cpp.

{
    notifyFrameCancelled(frame, cancelReason);
}

References KisAsyncAnimationRendererBase::notifyFrameCancelled().

frameCompletedCallback()

void KisAsyncAnimationFramesSavingRenderer::frameCompletedCallback ( int frame, const KisRegion & requestedRegion )

overrideprotectedvirtual

frameCompletedCallback is called by the renderer when a new frame becomes ready

NOTE1: the callback is called from the context of a image worker thread! So it is asynchronous from the GUI thread. NOTE2: in case of successful processing of the frame, the callback must issue some signal, connected to notifyFrameCompleted() via auto connection, to continue processing. Please do not call the method directly, because notifyFame*() slots should be called from the context of the GUI thread. NOTE3: In case of failure, notifyFrameCancelled(). The same threading rules apply.

Implements KisAsyncAnimationRendererBase.

Definition at line 86 of file KisAsyncAnimationFramesSavingRenderer.cpp.

{
    KisImageSP image = requestedImage();
    if (!image) return;
 
    KIS_SAFE_ASSERT_RECOVER (requestedRegion == image->bounds()) {
        Q_EMIT sigCancelRegenerationInternal(frame, KisAsyncAnimationRendererBase::RenderingFailed);
        return;
    }
 
    m_d->savingDevice->makeCloneFromRough(image->projection(), image->bounds());
 
    KisImportExportErrorCode status = ImportExportCodes::OK;
 
    QString frameNumber = QString("%1").arg(frame + m_d->sequenceNumberingOffset, 4, 10, QChar('0'));
    QString filename = m_d->filenamePrefix + frameNumber + m_d->filenameSuffix;
 
    if (!m_d->savingDoc->exportDocumentSync(filename, m_d->outputMimeType, m_d->exportConfiguration)) {
        status = ImportExportCodes::InternalError;
    }
 
    //Get all identical frames to this one and either copy or symlink based on settings.
    KisTimeSpan identicals = KisTimeSpan::calculateIdenticalFramesRecursive(image->root(), frame);
    identicals &= m_d->range;
    if( !m_d->onlyNeedsUniqueFrames && identicals.start() < identicals.end() ) {
        for (int identicalFrame = (identicals.start() + 1); identicalFrame <= identicals.end(); identicalFrame++) {
            QString identicalFrameNumber = QString("%1").arg(identicalFrame + m_d->sequenceNumberingOffset, 4, 10, QChar('0'));
            QString identicalFrameName = m_d->filenamePrefix + identicalFrameNumber + m_d->filenameSuffix;
 
            QFile::copy(filename, identicalFrameName);
 
            /*  This would be nice to do but sym-linking on windows isn't possible without
             *  way more other work to be done. This works on linux though!
             *
             *  if (m_d->linkRedundantFrames) {
             *      QFile::link(filename, identicalFrameName);
             *  } else {
             *      QFile::copy(filename, identicalFrameName);
             *  }
             */
        }
    }
 
    if (status.isOk()) {
        Q_EMIT sigCompleteRegenerationInternal(frame);
    } else {
        Q_EMIT sigCancelRegenerationInternal(frame, KisAsyncAnimationRendererBase::RenderingFailed);
    }
}

References KisImage::bounds(), KisTimeSpan::calculateIdenticalFramesRecursive(), KisTimeSpan::end(), ImportExportCodes::InternalError, KisImportExportErrorCode::isOk(), KIS_SAFE_ASSERT_RECOVER, m_d, ImportExportCodes::OK, KisImage::projection(), KisAsyncAnimationRendererBase::RenderingFailed, KisAsyncAnimationRendererBase::requestedImage, KisAsyncAnimationRendererBase::requestedRegion, KisNodeFacade::root, sigCancelRegenerationInternal(), sigCompleteRegenerationInternal(), and KisTimeSpan::start().

sigCancelRegenerationInternal

void KisAsyncAnimationFramesSavingRenderer::sigCancelRegenerationInternal ( int frame, KisAsyncAnimationRendererBase::CancelReason cancelReason )

signal

sigCompleteRegenerationInternal

void KisAsyncAnimationFramesSavingRenderer::sigCompleteRegenerationInternal ( int frame )

signal

Member Data Documentation

m_d

const QScopedPointer<Private> KisAsyncAnimationFramesSavingRenderer::m_d

private

Definition at line 39 of file KisAsyncAnimationFramesSavingRenderer.h.

---

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

• libs/ui/KisAsyncAnimationFramesSavingRenderer.h
• libs/ui/KisAsyncAnimationFramesSavingRenderer.cpp