KisDabRenderingQueue Class Reference

#include <KisDabRenderingQueue.h>

Classes
struct	CacheInterface
struct	Private

Public Member Functions
KisDabRenderingJobSP	addDab (const KisDabCacheUtils::DabRequestInfo &request, qreal opacity, qreal flow)
int	averageDabSize () const
qreal	averageExecutionTime () const
KisFixedPaintDeviceSP	fetchCachedPaintDevice ()
KisDabCacheUtils::DabRenderingResources *	fetchResourcesFromCache ()
bool	hasPreparedDabs () const
	KisDabRenderingQueue (const KoColorSpace *cs, KisDabCacheUtils::ResourcesFactory resourcesFactory)
QList< KisDabRenderingJobSP >	notifyJobFinished (int seqNo, int usecsTime=-1)
void	putResourcesToCache (KisDabCacheUtils::DabRenderingResources *resources)
void	setCacheInterface (CacheInterface *interface)
QList< KisRenderedDab >	takeReadyDabs (bool returnMutableDabs=false, int oneTimeLimit=-1, bool *someDabsLeft=0)
int	testingGetQueueSize () const
	~KisDabRenderingQueue ()

Private Attributes
const QScopedPointer< Private >	m_d

Detailed Description

Definition at line 20 of file KisDabRenderingQueue.h.

Constructor & Destructor Documentation

KisDabRenderingQueue()

KisDabRenderingQueue::KisDabRenderingQueue	(	const KoColorSpace *	cs,
		KisDabCacheUtils::ResourcesFactory	resourcesFactory )

Definition at line 95 of file KisDabRenderingQueue.cpp.

    : m_d(new Private(cs, resourcesFactory))
{
}

~KisDabRenderingQueue()

KisDabRenderingQueue::~KisDabRenderingQueue

(

)

Definition at line 101 of file KisDabRenderingQueue.cpp.

{
}

Member Function Documentation

addDab()

KisDabRenderingJobSP KisDabRenderingQueue::addDab	(	const KisDabCacheUtils::DabRequestInfo &	request,
		qreal	opacity,
		qreal	flow )

Definition at line 127 of file KisDabRenderingQueue.cpp.

{
    QMutexLocker l(&m_d->mutex);
 
    const int seqNo = m_d->nextSeqNoToUse++;
 
    KisDabCacheUtils::DabRenderingResources *resources = m_d->fetchResourcesFromCache();
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(resources, KisDabRenderingJobSP());
 
    // We should sync the cached brush into the current seqNo
    resources->syncResourcesToSeqNo(seqNo, request.info);
 
    const int lastDabJobIndex = m_d->lastDabJobInQueue;
 
    KisDabRenderingJobSP job(new KisDabRenderingJob(seqNo, KisDabRenderingJob::Dab, opacity, flow));
 
    bool shouldUseCache = false;
    m_d->cacheInterface->getDabType(lastDabJobIndex >= 0, resources, request, &job->generationInfo, &shouldUseCache);
 
    m_d->putResourcesToCache(resources);
    resources = nullptr;
 
    job->type = !shouldUseCache                   ? KisDabRenderingJob::Dab
        : job->generationInfo.needsPostprocessing ? KisDabRenderingJob::Postprocess
                                                  : KisDabRenderingJob::Copy;
 
    if (job->type == KisDabRenderingJob::Dab) {
        job->status = KisDabRenderingJob::Running;
    } else if (job->type == KisDabRenderingJob::Postprocess ||
               job->type == KisDabRenderingJob::Copy) {
 
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(lastDabJobIndex >= 0, KisDabRenderingJobSP());
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(lastDabJobIndex < m_d->jobs.size(), KisDabRenderingJobSP());
 
        if (m_d->jobs[lastDabJobIndex]->status == KisDabRenderingJob::Completed) {
            if (job->type == KisDabRenderingJob::Postprocess) {
                job->status = KisDabRenderingJob::Running;
                job->originalDevice = m_d->jobs[lastDabJobIndex]->originalDevice;
            } else if (job->type == KisDabRenderingJob::Copy) {
                job->status = KisDabRenderingJob::Completed;
                job->originalDevice = m_d->jobs[lastDabJobIndex]->originalDevice;
                job->postprocessedDevice = m_d->jobs[lastDabJobIndex]->postprocessedDevice;
                m_d->avgExecutionTime(0);
            }
        }
    }
 
    m_d->jobs.append(job);
 
    KisDabRenderingJobSP jobToRun;
    if (job->status == KisDabRenderingJob::Running) {
        jobToRun = job;
    }
 
    if (job->type == KisDabRenderingJob::Dab) {
        m_d->lastDabJobInQueue = m_d->jobs.size() - 1;
        m_d->cleanPaintedDabs();
    }
 
    // collect some statistics about the dab
    m_d->avgDabSize(KisAlgebra2D::maxDimension(job->generationInfo.dstDabRect));
 
    return jobToRun;
}

References KisDabRenderingJob::Completed, KisDabRenderingJob::Copy, KisDabRenderingJob::Dab, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_d, KisAlgebra2D::maxDimension(), KisDabRenderingJob::Postprocess, KisDabRenderingJob::Running, and KisDabCacheUtils::DabRenderingResources::syncResourcesToSeqNo().

averageDabSize()

int KisDabRenderingQueue::averageDabSize

(

)

const

Definition at line 381 of file KisDabRenderingQueue.cpp.

{
    QMutexLocker l(&m_d->mutex);
    return qRound(m_d->avgDabSize.rollingMean());
}

References m_d.

averageExecutionTime()

qreal KisDabRenderingQueue::averageExecutionTime

(

)

const

Definition at line 375 of file KisDabRenderingQueue.cpp.

{
    QMutexLocker l(&m_d->mutex);
    return m_d->avgExecutionTime.rollingMean() / 1000.0;
}

References m_d.

fetchCachedPaintDevice()

KisFixedPaintDeviceSP KisDabRenderingQueue::fetchCachedPaintDevice

(

)

We create a special type of a fixed paint device that uses a custom allocator for better efficiency.

Definition at line 366 of file KisDabRenderingQueue.cpp.

{
    return new KisFixedPaintDevice(m_d->colorSpace, m_d->paintDeviceAllocator);
}

References m_d.

fetchResourcesFromCache()

KisDabCacheUtils::DabRenderingResources * KisDabRenderingQueue::fetchResourcesFromCache

(

)

Definition at line 417 of file KisDabRenderingQueue.cpp.

{
    // TODO: make a separate lock for that
    QMutexLocker l(&m_d->mutex);
    return m_d->fetchResourcesFromCache();
}

References m_d.

hasPreparedDabs()

bool KisDabRenderingQueue::hasPreparedDabs

(

)

const

Definition at line 355 of file KisDabRenderingQueue.cpp.

{
    QMutexLocker l(&m_d->mutex);
    return m_d->hasPreparedDabsImpl();
}

References m_d.

notifyJobFinished()

QList< KisDabRenderingJobSP > KisDabRenderingQueue::notifyJobFinished	(	int	seqNo,
		int	usecsTime = -1 )

Here we use binary search for locating the necessary original dab

Definition at line 193 of file KisDabRenderingQueue.cpp.

{
    QMutexLocker l(&m_d->mutex);
 
    QList<KisDabRenderingJobSP> dependentJobs;
 
    auto finishedJobIt =
        std::lower_bound(m_d->jobs.begin(), m_d->jobs.end(), seqNo,
                         kismpl::mem_less(&KisDabRenderingJob::seqNo));
 
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(finishedJobIt != m_d->jobs.end(), dependentJobs);
    KisDabRenderingJobSP finishedJob = *finishedJobIt;
 
    KIS_SAFE_ASSERT_RECOVER_NOOP(finishedJob->status == KisDabRenderingJob::Running);
    KIS_SAFE_ASSERT_RECOVER_NOOP(finishedJob->seqNo == seqNo);
    KIS_SAFE_ASSERT_RECOVER_NOOP(finishedJob->originalDevice);
    KIS_SAFE_ASSERT_RECOVER_NOOP(finishedJob->postprocessedDevice);
 
    finishedJob->status = KisDabRenderingJob::Completed;
 
    if (finishedJob->type == KisDabRenderingJob::Dab) {
        for (auto it = finishedJobIt + 1; it != m_d->jobs.end(); ++it) {
            KisDabRenderingJobSP j = *it;
 
            // next dab job closes the chain
            if (j->type == KisDabRenderingJob::Dab) break;
 
            // the non 'dab'-type job couldn't have
            // been started before the source ob was completed
            KIS_SAFE_ASSERT_RECOVER_BREAK(j->status == KisDabRenderingJob::New);
 
            if (j->type == KisDabRenderingJob::Copy) {
 
                j->originalDevice = finishedJob->originalDevice;
                j->postprocessedDevice = finishedJob->postprocessedDevice;
                j->status = KisDabRenderingJob::Completed;
                m_d->avgExecutionTime(0);
 
            } else if (j->type == KisDabRenderingJob::Postprocess) {
 
                j->originalDevice = finishedJob->originalDevice;
                j->status = KisDabRenderingJob::Running;
                dependentJobs << j;
            }
        }
    }
 
    if (usecsTime >= 0) {
        m_d->avgExecutionTime(usecsTime);
    }
 
    return dependentJobs;
}

References KisDabRenderingJob::Completed, KisDabRenderingJob::Copy, KisDabRenderingJob::Dab, KIS_SAFE_ASSERT_RECOVER_BREAK, KIS_SAFE_ASSERT_RECOVER_NOOP, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_d, kismpl::mem_less(), KisDabRenderingJob::New, KisDabRenderingJob::Postprocess, KisDabRenderingJob::Running, and KisDabRenderingJob::seqNo.

putResourcesToCache()

void KisDabRenderingQueue::putResourcesToCache

(

KisDabCacheUtils::DabRenderingResources *

resources

)

Definition at line 424 of file KisDabRenderingQueue.cpp.

{
    QMutexLocker l(&m_d->mutex);
    m_d->putResourcesToCache(resources);
}

References m_d.

setCacheInterface()

void KisDabRenderingQueue::setCacheInterface

(

KisDabRenderingQueue::CacheInterface *

interface

)

Definition at line 361 of file KisDabRenderingQueue.cpp.

{
    m_d->cacheInterface.reset(interface);
}

References m_d.

takeReadyDabs()

QList< KisRenderedDab > KisDabRenderingQueue::takeReadyDabs	(	bool	returnMutableDabs = false,
		int	oneTimeLimit = -1,
		bool *	someDabsLeft = 0 )

Definition at line 285 of file KisDabRenderingQueue.cpp.

{
    QMutexLocker l(&m_d->mutex);
 
    QList<KisRenderedDab> renderedDabs;
    if (m_d->jobs.isEmpty()) return renderedDabs;
 
    KIS_SAFE_ASSERT_RECOVER_NOOP(
        m_d->jobs.isEmpty() ||
        m_d->jobs.first()->type == KisDabRenderingJob::Dab);
 
    const int copyJobAfterInclusive =
        returnMutableDabs && !m_d->dabsHaveSeparateOriginal() ?
            m_d->lastDabJobInQueue :
            std::numeric_limits<int>::max();
 
    if (oneTimeLimit < 0) {
        oneTimeLimit = std::numeric_limits<int>::max();
    }
 
    for (int i = 0; i < m_d->jobs.size() && oneTimeLimit > 0; i++, oneTimeLimit--) {
        KisDabRenderingJobSP j = m_d->jobs[i];
 
        if (j->status != KisDabRenderingJob::Completed) break;
 
        if (i <= m_d->lastPaintedJob) continue;
 
        KisRenderedDab dab;
        KisFixedPaintDeviceSP resultDevice = j->postprocessedDevice;
 
        if (i >= copyJobAfterInclusive) {
            resultDevice = new KisFixedPaintDevice(*resultDevice);
        }
 
        dab.device = resultDevice;
        dab.offset = j->dstDabOffset();
        dab.opacity = j->opacity;
        dab.flow = j->flow;
 
        m_d->averageOpacity = KisPainter::blendAverageOpacity(j->opacity, m_d->averageOpacity);
        dab.averageOpacity = m_d->averageOpacity;
 
 
        renderedDabs.append(dab);
 
        m_d->lastPaintedJob = i;
    }
 
    m_d->cleanPaintedDabs();
 
    if (someDabsLeft) {
        *someDabsLeft = m_d->hasPreparedDabsImpl();
    }
 
    return renderedDabs;
}

References KisRenderedDab::averageOpacity, KisPainter::blendAverageOpacity(), KisDabRenderingJob::Completed, KisDabRenderingJob::Dab, KisRenderedDab::device, KisRenderedDab::flow, KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, KisRenderedDab::offset, and KisRenderedDab::opacity.

testingGetQueueSize()

int KisDabRenderingQueue::testingGetQueueSize

(

)

const

Definition at line 430 of file KisDabRenderingQueue.cpp.

{
    QMutexLocker l(&m_d->mutex);
 
    return m_d->jobs.size();
}

References m_d.

Member Data Documentation

m_d

const QScopedPointer<Private> KisDabRenderingQueue::m_d

private

Definition at line 63 of file KisDabRenderingQueue.h.

---

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

• plugins/paintops/defaultpaintops/brush/KisDabRenderingQueue.h
• plugins/paintops/defaultpaintops/brush/KisDabRenderingQueue.cpp