KisAsyncAnimationRenderDialogBase Class Reference

KisAsyncAnimationRenderDialogBase is a special class for rendering multiple frames of the image and putting them somewhere (saving into a file or just pushing into an openGL cache) More...

#include <KisAsyncAnimationRenderDialogBase.h>

Inheritance diagram for KisAsyncAnimationRenderDialogBase:

Classes
struct	Private

Public Types
enum	Result { RenderComplete , RenderCancelled , RenderFailed , RenderTimedOut }

Public Member Functions
bool	batchMode () const
	KisAsyncAnimationRenderDialogBase (const QString &actionTitle, KisImageSP image, int busyWait=200)
	construct and initialize the dialog
virtual Result	regenerateRange (KisViewManager *viewManager)
	start generation of frames and (if not in batch mode) show the dialog
KisRegion	regionOfInterest () const
void	setBatchMode (bool value)
	setting batch mode to true will prevent any dialogs or message boxes from showing on screen. Please take it into account that using batch mode prevents some potentially dangerous recovery execution paths (e.g. delete the existing frames in the destination folder). In such case the rendering will be stopped with RenderFailed result.
void	setRegionOfInterest (const KisRegion &roi)
virtual	~KisAsyncAnimationRenderDialogBase ()

Protected Member Functions
virtual QList< int >	calcDirtyFrames () const =0
	returns a list of frames that should be regenerated by the dialog
virtual KisAsyncAnimationRendererBase *	createRenderer (KisImageSP image)=0
	create a renderer object linked to image
virtual void	initializeRendererForFrame (KisAsyncAnimationRendererBase *renderer, KisImageSP image, int frame)=0

Private Slots
void	slotCancelRegeneration ()
void	slotFrameCancelled (int frame, KisAsyncAnimationRendererBase::CancelReason cancelReason)
void	slotFrameCompleted (int frame)
void	slotUpdateCompressedProgressData ()

Private Member Functions
void	cancelProcessingImpl (KisAsyncAnimationRendererBase::CancelReason cancelReason)
void	tryInitiateFrameRegeneration ()
void	updateProgressLabel ()

Private Attributes
const QScopedPointer< Private >	m_d

Detailed Description

KisAsyncAnimationRenderDialogBase is a special class for rendering multiple frames of the image and putting them somewhere (saving into a file or just pushing into an openGL cache)

The class handles a lot of boilerplate code for you and optimizes regeneration of the frames using multithreading, according to the user's settings. The responsibilities of the class are the following:

Rendering itself:

• fetch the list of dirty frames using calcDirtyFrames()
• create some clones of the image according to the user's settings to facilitate multithreaded rendering and processing of the frames
• if the user doesn't have enough RAM, the clones will not be created (the memory overhead is calculated using "projections" metric of the statistics server).
• feed the images/threads with dirty frames until the all the frames are done

Progress reporting:

• if batchMode() is false, the user will see a progress dialog showing the current progress with estimate about total processing timer
• the user can also cancel the regeneration by pressing Cancel button

Usage Details:

• one should implement two methods to make the rendering work:
  • calcDirtyFrames()
  • createRenderer(KisImageSP image)
• these methods will be called on the start of the rendering

Definition at line 50 of file KisAsyncAnimationRenderDialogBase.h.

Member Enumeration Documentation

Result

enum KisAsyncAnimationRenderDialogBase::Result

Enumerator
RenderComplete
RenderCancelled
RenderFailed
RenderTimedOut

Definition at line 54 of file KisAsyncAnimationRenderDialogBase.h.

                {
        RenderComplete,
        RenderCancelled,
        RenderFailed,
        RenderTimedOut
    };

Constructor & Destructor Documentation

KisAsyncAnimationRenderDialogBase()

KisAsyncAnimationRenderDialogBase::KisAsyncAnimationRenderDialogBase	(	const QString &	actionTitle,
		KisImageSP	image,
		int	busyWait = 200 )

construct and initialize the dialog

Parameters

actionTitle	the first line of the status reports that the user sees in the dialog
image	the image that will be as a source of frames. Make sure the image is not locked by the time regenerateRange() is called
busyWait	the dialog will not show for the specified time (in milliseconds)

Definition at line 112 of file KisAsyncAnimationRenderDialogBase.cpp.

    : m_d(new Private(actionTitle, image, busyWait))
{
    connect(&m_d->progressDialogCompressor, SIGNAL(timeout()),
            SLOT(slotUpdateCompressedProgressData()), Qt::QueuedConnection);
}

References connect(), m_d, and slotUpdateCompressedProgressData().

~KisAsyncAnimationRenderDialogBase()

KisAsyncAnimationRenderDialogBase::~KisAsyncAnimationRenderDialogBase ( )

virtual

Definition at line 119 of file KisAsyncAnimationRenderDialogBase.cpp.

{
}

Member Function Documentation

batchMode()

bool KisAsyncAnimationRenderDialogBase::batchMode

(

)

const

See also

setBatchMode

Definition at line 404 of file KisAsyncAnimationRenderDialogBase.cpp.

{
    return m_d->isBatchMode;
}

References m_d.

calcDirtyFrames()

virtual QList< int > KisAsyncAnimationRenderDialogBase::calcDirtyFrames ( ) const

protectedpure virtual

returns a list of frames that should be regenerated by the dialog

Called by the dialog in the very beginning of regenerateRange()

Implemented in KisAsyncAnimationCacheRenderDialog, and KisAsyncAnimationFramesSaveDialog.

cancelProcessingImpl()

void KisAsyncAnimationRenderDialogBase::cancelProcessingImpl ( KisAsyncAnimationRendererBase::CancelReason cancelReason )

private

Definition at line 286 of file KisAsyncAnimationRenderDialogBase.cpp.

{
    for (auto &pair : m_d->asyncRenderers) {
        if (pair.renderer->isActive()) {
            pair.renderer->cancelCurrentFrameRendering(cancelReason);
        }
        KIS_SAFE_ASSERT_RECOVER_NOOP(!pair.renderer->isActive());
    }
 
    m_d->stillDirtyFrames.clear();
    m_d->framesInProgress.clear();
    m_d->result =
        cancelReason == KisAsyncAnimationRendererBase::UserCancelled ? RenderCancelled :
        cancelReason == KisAsyncAnimationRendererBase::RenderingFailed ? RenderFailed :
        RenderTimedOut;
    updateProgressLabel();
}

References KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, RenderCancelled, RenderFailed, KisAsyncAnimationRendererBase::RenderingFailed, RenderTimedOut, updateProgressLabel(), and KisAsyncAnimationRendererBase::UserCancelled.

createRenderer()

virtual KisAsyncAnimationRendererBase * KisAsyncAnimationRenderDialogBase::createRenderer ( KisImageSP image )

protectedpure virtual

create a renderer object linked to image

Renderer are special objects that connect to the individual image signals, react on them and fetch the final frames data

See also

KisAsyncAnimationRendererBase

Implemented in KisAsyncAnimationCacheRenderDialog, and KisAsyncAnimationFramesSaveDialog.

initializeRendererForFrame()

virtual void KisAsyncAnimationRenderDialogBase::initializeRendererForFrame ( KisAsyncAnimationRendererBase * renderer, KisImageSP image, int frame )

protectedpure virtual

Implemented in KisAsyncAnimationCacheRenderDialog, and KisAsyncAnimationFramesSaveDialog.

regenerateRange()

KisAsyncAnimationRenderDialogBase::Result KisAsyncAnimationRenderDialogBase::regenerateRange ( KisViewManager * viewManager )

virtual

start generation of frames and (if not in batch mode) show the dialog

The link to view manager is used to barrier lock with visual feedback in the end of the operation

Since this method can be called from the places where no view manager is available, we need this manually crafted ugly construction to "try-lock-cancel" the image.

Reimplemented in KisAsyncAnimationFramesSaveDialog.

Definition at line 124 of file KisAsyncAnimationRenderDialogBase.cpp.

{
    KisBlockBackgroundFrameGenerationLock populatorBlock(m_d->image->animationInterface());
 
    {
        bool imageIsIdle = true;
 
        if (viewManager) {
            imageIsIdle = viewManager->blockUntilOperationsFinished(m_d->image);
        } else {
            imageIsIdle = false;
            if (m_d->image->tryBarrierLock(true)) {
                m_d->image->unlock();
                imageIsIdle = true;
            }
        }
 
        if (!imageIsIdle) {
            return RenderCancelled;
        }
    }
 
 
    if (!m_d->isBatchMode) {
        QWidget *parentWidget = viewManager ? viewManager->mainWindowAsQWidget() : 0;
        KisLockFrameGenerationLockAdapter adapter(m_d->image->animationInterface());
        KisAsyncActionFeedback feedback(i18n("Wait for existing frame generation process to complete..."), parentWidget);
        feedback.waitForMutex(adapter);
    }
 
    m_d->stillDirtyFrames = calcDirtyFrames();
    m_d->framesInProgress.clear();
    m_d->result = RenderComplete;
    m_d->dirtyFramesCount = m_d->stillDirtyFrames.size();
 
    if (!m_d->isBatchMode) {
        QWidget *parentWidget = viewManager ? viewManager->mainWindowAsQWidget() : 0;
        m_d->progressDialog.reset(new QProgressDialog(m_d->actionTitle, i18n("Cancel"), 0, 0, parentWidget));
        m_d->progressDialog->setWindowModality(Qt::ApplicationModal);
        m_d->progressDialog->setMinimum(0);
        m_d->progressDialog->setMaximum(m_d->dirtyFramesCount);
        m_d->progressDialog->setMinimumDuration(m_d->busyWait);
        connect(m_d->progressDialog.data(), SIGNAL(canceled()), SLOT(slotCancelRegeneration()));
    }
 
    if (m_d->dirtyFramesCount <= 0) return m_d->result;
 
    m_d->processingTime.start();
 
    KisImageConfig cfg(true);
 
    const int maxThreads = cfg.maxNumberOfThreads();
    const int numAllowedWorker = 1 + calculateNumberMemoryAllowedClones(m_d->image);
    const int proposedNumWorkers = qMin(m_d->dirtyFramesCount, cfg.frameRenderingClones());
    const int numWorkers = qMin(proposedNumWorkers, numAllowedWorker);
    const int numThreadsPerWorker = qMax(1, qCeil(qreal(maxThreads) / numWorkers));
 
    m_d->memoryLimitReached = numWorkers < proposedNumWorkers;
 
    const int oldWorkingThreadsLimit = m_d->image->workingThreadsLimit();
 
    for (int i = 0; i < numWorkers; i++) {
        // reuse the image for one of the workers
        const bool lastWorker = (i == numWorkers - 1);
        KisImageSP image = m_d->image;
 
        if (!lastWorker) {
            //Only the last-most worker should try to use the source image pointer. Others need a copy.
 
            if (m_d->asyncRenderers.size() == 0) {
                // Copy source image when no renderers (aka no copies) exist, requires lock as image memory can be actively modified.
                m_d->image->barrierLock(true);
                image = m_d->image->clone(true);
                m_d->image->unlock();
            } else {
                // Copy a previous copy, shouldn't require lock since image is "fresh" and untouchable by other krita systems.
                image = m_d->asyncRenderers[m_d->asyncRenderers.size() - 1].image->clone(true);
            }
        }
 
 
        image->setWorkingThreadsLimit(numThreadsPerWorker);
        KisAsyncAnimationRendererBase *renderer = createRenderer(image);
 
        connect(renderer, SIGNAL(sigFrameCompleted(int)), SLOT(slotFrameCompleted(int)));
        connect(renderer, SIGNAL(sigFrameCancelled(int, KisAsyncAnimationRendererBase::CancelReason)), SLOT(slotFrameCancelled(int, KisAsyncAnimationRendererBase::CancelReason)));
 
        m_d->asyncRenderers.push_back(RendererPair(renderer, image));
    }
 
 
    tryInitiateFrameRegeneration();
    updateProgressLabel();
 
    if (m_d->numDirtyFramesLeft() > 0) {
        m_d->waitLoop.exec();
    }
 
    for (auto &pair : m_d->asyncRenderers) {
        KIS_SAFE_ASSERT_RECOVER_NOOP(!pair.renderer->isActive());
        if (viewManager) {
            viewManager->blockUntilOperationsFinishedForced(pair.image);
        } else {
            pair.image->barrierLock(true);
            pair.image->unlock();
        }
 
    }
    m_d->asyncRenderers.clear();
 
    if (viewManager) {
        viewManager->blockUntilOperationsFinishedForced(m_d->image);
    } else {
        m_d->image->barrierLock(true);
        m_d->image->unlock();
    }
 
    m_d->image->setWorkingThreadsLimit(oldWorkingThreadsLimit);
 
    m_d->progressDialog.reset();
 
    return m_d->result;
}

References KisImage::barrierLock(), KisViewManager::blockUntilOperationsFinished(), KisViewManager::blockUntilOperationsFinishedForced(), calcDirtyFrames(), KisImage::clone(), connect(), createRenderer(), KisImageConfig::frameRenderingClones(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, KisViewManager::mainWindowAsQWidget(), KisImageConfig::maxNumberOfThreads(), RenderCancelled, RenderComplete, KisImage::setWorkingThreadsLimit(), slotCancelRegeneration(), slotFrameCancelled(), slotFrameCompleted(), tryInitiateFrameRegeneration(), KisImage::unlock(), updateProgressLabel(), and KisAsyncActionFeedback::waitForMutex().

regionOfInterest()

KisRegion KisAsyncAnimationRenderDialogBase::regionOfInterest

(

)

const

See also

setRegionOfInterest()

Definition at line 259 of file KisAsyncAnimationRenderDialogBase.cpp.

{
    return m_d->regionOfInterest;
}

References m_d.

setBatchMode()

void KisAsyncAnimationRenderDialogBase::setBatchMode

(

bool

value

)

setting batch mode to true will prevent any dialogs or message boxes from showing on screen. Please take it into account that using batch mode prevents some potentially dangerous recovery execution paths (e.g. delete the existing frames in the destination folder). In such case the rendering will be stopped with RenderFailed result.

Definition at line 399 of file KisAsyncAnimationRenderDialogBase.cpp.

{
    m_d->isBatchMode = value;
}

References m_d, and value().

setRegionOfInterest()

void KisAsyncAnimationRenderDialogBase::setRegionOfInterest

(

const KisRegion &

roi

)

Set area of image that will be regenerated. If roi is empty, full area of the image is regenerated.

Definition at line 254 of file KisAsyncAnimationRenderDialogBase.cpp.

{
    m_d->regionOfInterest = roi;
}

References m_d.

slotCancelRegeneration

void KisAsyncAnimationRenderDialogBase::slotCancelRegeneration ( )

privateslot

Definition at line 281 of file KisAsyncAnimationRenderDialogBase.cpp.

{
    cancelProcessingImpl(KisAsyncAnimationRendererBase::UserCancelled);
}

References cancelProcessingImpl(), and KisAsyncAnimationRendererBase::UserCancelled.

slotFrameCancelled

void KisAsyncAnimationRenderDialogBase::slotFrameCancelled ( int frame, KisAsyncAnimationRendererBase::CancelReason cancelReason )

privateslot

Definition at line 274 of file KisAsyncAnimationRenderDialogBase.cpp.

{
    Q_UNUSED(frame);
 
    cancelProcessingImpl(cancelReason);
}

References cancelProcessingImpl().

slotFrameCompleted

void KisAsyncAnimationRenderDialogBase::slotFrameCompleted ( int frame )

privateslot

Definition at line 264 of file KisAsyncAnimationRenderDialogBase.cpp.

{
    Q_UNUSED(frame);
 
    m_d->framesInProgress.removeOne(frame);
 
    tryInitiateFrameRegeneration();
    updateProgressLabel();
}

References m_d, tryInitiateFrameRegeneration(), and updateProgressLabel().

slotUpdateCompressedProgressData

void KisAsyncAnimationRenderDialogBase::slotUpdateCompressedProgressData ( )

privateslot

Qt's implementation of QProgressDialog is a bit weird: it calls QApplication::processEvents() from inside setValue(), which means that our update method may reenter multiple times.

This code avoids reentering by using a compressor and an explicit entrance counter.

Definition at line 372 of file KisAsyncAnimationRenderDialogBase.cpp.

{
    if (m_d->progressDialogReentrancyCounter > 0) {
        m_d->progressDialogCompressor.start();
        return;
    }
 
    if (m_d->progressDialog && m_d->progressData) {
        m_d->progressDialogReentrancyCounter++;
 
        m_d->progressDialog->setLabelText(m_d->progressData->second);
        m_d->progressDialog->setValue(m_d->progressData->first);
        m_d->progressData = boost::none;
 
        m_d->progressDialogReentrancyCounter--;
    }
}

References m_d.

tryInitiateFrameRegeneration()

void KisAsyncAnimationRenderDialogBase::tryInitiateFrameRegeneration ( )

private

Definition at line 305 of file KisAsyncAnimationRenderDialogBase.cpp.

{
    bool hadWorkOnPreviousCycle = false;
 
    while (!m_d->stillDirtyFrames.isEmpty()) {
        for (auto &pair : m_d->asyncRenderers) {
            if (!pair.renderer->isActive()) {
                const int currentDirtyFrame = m_d->stillDirtyFrames.takeFirst();
 
                KisLockFrameGenerationLock lock(pair.image->animationInterface());
 
                initializeRendererForFrame(pair.renderer.get(), pair.image, currentDirtyFrame);
                pair.renderer->startFrameRegeneration(pair.image, currentDirtyFrame, m_d->regionOfInterest,
                                                      KisAsyncAnimationRendererBase::None, std::move(lock));
                hadWorkOnPreviousCycle = true;
                m_d->framesInProgress.append(currentDirtyFrame);
                break;
            }
        }
 
        if (!hadWorkOnPreviousCycle) break;
        hadWorkOnPreviousCycle = false;
    }
}

References initializeRendererForFrame(), m_d, and KisAsyncAnimationRendererBase::None.

updateProgressLabel()

void KisAsyncAnimationRenderDialogBase::updateProgressLabel ( )

private

We should avoid reentrancy caused by explicit QApplication::processEvents() in QProgressDialog::setValue(), so use a compressor instead

Definition at line 330 of file KisAsyncAnimationRenderDialogBase.cpp.

{
    const int processedFramesCount = m_d->dirtyFramesCount - m_d->numDirtyFramesLeft();
 
    const qint64 elapsedMSec = m_d->processingTime.elapsed();
    const qint64 estimatedMSec =
        !processedFramesCount ? 0 :
        elapsedMSec * m_d->dirtyFramesCount / processedFramesCount;
 
    const QTime elapsedTime = QTime::fromMSecsSinceStartOfDay(elapsedMSec);
    const QTime estimatedTime = QTime::fromMSecsSinceStartOfDay(estimatedMSec);
 
    const QString timeFormat = estimatedTime.hour() > 0 ? "HH:mm:ss" : "mm:ss";
 
    const QString elapsedTimeString = elapsedTime.toString(timeFormat);
    const QString estimatedTimeString = estimatedTime.toString(timeFormat);
 
    const QString memoryLimitMessage(
        i18n("\n\nThe memory limit has been reached.\nThe number of frames saved simultaneously is limited to %1\n\n",
             m_d->asyncRenderers.size()));
 
 
    const QString progressLabel(i18n("%1\n\nElapsed: %2\nEstimated: %3\n\n%4",
                                     m_d->actionTitle,
                                     elapsedTimeString,
                                     estimatedTimeString,
                                     m_d->memoryLimitReached ? memoryLimitMessage : QString()));
    if (m_d->progressDialog) {
        m_d->progressData = Private::ProgressData(processedFramesCount, progressLabel);
        m_d->progressDialogCompressor.start();
    }
 
    if (!m_d->numDirtyFramesLeft()) {
        m_d->waitLoop.quit();
    }
}

References m_d.

Member Data Documentation

m_d

const QScopedPointer<Private> KisAsyncAnimationRenderDialogBase::m_d

private

Definition at line 140 of file KisAsyncAnimationRenderDialogBase.h.

---

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

• libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.h
• libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.cpp