#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 67 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 m_d, KisAsyncAnimationRendererBase::notifyFrameCancelled(), KisAsyncAnimationRendererBase::notifyFrameCompleted(), sigCancelRegenerationInternal(), and sigCompleteRegenerationInternal().

◆ ~KisAsyncAnimationFramesSavingRenderer()

KisAsyncAnimationFramesSavingRenderer::~KisAsyncAnimationFramesSavingRenderer ( )

Definition at line 88 of file KisAsyncAnimationFramesSavingRenderer.cpp.

89{

90}

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 162 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 92 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.
    if (status.isOk()) {
        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;
 
                bool copyOk;
                QString copyErrorMessage;
#ifdef Q_OS_ANDROID
                copyOk = KisAndroidUtils::copyFile(filename, identicalFrameName, &copyErrorMessage);
#else
                QFile sourceFile(filename);
                if (sourceFile.copy(identicalFrameName)) {
                    copyOk = true;
                } else {
                    copyOk = false;
                    copyErrorMessage = sourceFile.errorString();
                }
#endif
                if (!copyOk) {
                    warnFile.nospace() << "Failed to copy frame '" << filename << "' to '" << identicalFrameName
                                       << "': " << copyErrorMessage;
                    status = ImportExportCodes::ErrorWhileWriting;
                    break;
                }
 
                /*  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(), KisAndroidUtils::copyFile(), KisTimeSpan::end(), ImportExportCodes::ErrorWhileWriting, ImportExportCodes::InternalError, KisImportExportErrorCode::isOk(), KIS_SAFE_ASSERT_RECOVER, m_d, ImportExportCodes::OK, KisImage::projection(), KisAsyncAnimationRendererBase::RenderingFailed, KisAsyncAnimationRendererBase::requestedImage, KisAsyncAnimationRendererBase::requestedRegion, KisNodeFacade::root, sigCancelRegenerationInternal(), sigCompleteRegenerationInternal(), KisTimeSpan::start(), and warnFile.

◆ 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

Classes

Signals

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members