RecorderWriterManager Class Reference

#include <recorder_writer.h>

Inheritance diagram for RecorderWriterManager:

Classes
class	Private

Signals
void	frameWriteFailed ()
void	lowPerformanceWarning ()
void	recorderStopWarning ()
void	startCapturing (int writerId, int index, KisPaintDeviceSP device)
void	started ()
void	stopped ()

Public Member Functions
RecorderWriterManager &	operator= (const RecorderWriterManager &)=delete
RecorderWriterManager &	operator= (RecorderWriterManager &&)=delete
	RecorderWriterManager ()=delete
	RecorderWriterManager (const RecorderExportSettings &es)
	RecorderWriterManager (const RecorderWriterManager &)=delete
	RecorderWriterManager (RecorderWriterManager &&)=delete
void	setCanvas (QPointer< KisCanvas2 > canvas)
void	setEnabled (bool enabled)
void	setup (const RecorderWriterSettings &settings)
void	start (bool toggleEnabled=true)
bool	stop (bool toggleEnabled=true)
	~RecorderWriterManager ()

Public Attributes
ThreadCounter	recorderThreads {}

Private Slots
void	onCapturingDone (int workerId, bool success)
void	onImageModified ()
void	onTimer ()
void	onToolChanged (const QString &toolId)
void	onToolPrimaryActionActivated (bool activated)

Private Attributes
Private *const	d
const RecorderExportSettings &	exporterSettings

Detailed Description

Definition at line 100 of file recorder_writer.h.

Constructor & Destructor Documentation

RecorderWriterManager() [1/4]

RecorderWriterManager::RecorderWriterManager ( const RecorderExportSettings & es )

explicit

Definition at line 497 of file recorder_writer.cpp.

    : d(new Private(this, recorderThreads))
    , exporterSettings(es)
{
    d->timer.setTimerType(Qt::PreciseTimer);
}

References d, and RecorderWriterManager::Private::timer.

~RecorderWriterManager()

RecorderWriterManager::~RecorderWriterManager

(

)

Definition at line 504 of file recorder_writer.cpp.

{
    delete d;
}

References d.

RecorderWriterManager() [2/4]

RecorderWriterManager::RecorderWriterManager ( )

delete

RecorderWriterManager() [3/4]

RecorderWriterManager::RecorderWriterManager ( const RecorderWriterManager & )

delete

RecorderWriterManager() [4/4]

RecorderWriterManager::RecorderWriterManager ( RecorderWriterManager && )

delete

Member Function Documentation

frameWriteFailed

void RecorderWriterManager::frameWriteFailed ( )

signal

lowPerformanceWarning

void RecorderWriterManager::lowPerformanceWarning ( )

signal

onCapturingDone

void RecorderWriterManager::onCapturingDone ( int workerId, bool success )

privateslot

Definition at line 655 of file recorder_writer.cpp.

{
    if (workerId >= d->writerPool.size())
        return;
    d->writerPool[workerId].inUse = false;
    d->writerPool[workerId].thread->setPriority(QThread::IdlePriority);
    recorderThreads.decUsedAndNotify();
    if (!success) {
        stop();
        Q_EMIT frameWriteFailed();
    }
}

References d, ThreadCounter::decUsedAndNotify(), frameWriteFailed(), recorderThreads, stop(), and RecorderWriterManager::Private::writerPool.

onImageModified

void RecorderWriterManager::onImageModified ( )

privateslot

Definition at line 668 of file recorder_writer.cpp.

{
    if (!d->enabled || !d->canStartCapture())
        return;
 
    if ((!d->settings.recordIsolateLayerMode) &&
            (d->canvas->image()->isIsolatingLayer() || d->canvas->image()->isIsolatingGroup()))
        return;
 
    d->imageModified = true;
}

References RecorderWriterManager::Private::canStartCapture(), RecorderWriterManager::Private::canvas, d, RecorderWriterManager::Private::enabled, RecorderWriterManager::Private::imageModified, RecorderWriterSettings::recordIsolateLayerMode, and RecorderWriterManager::Private::settings.

onTimer

void RecorderWriterManager::onTimer ( )

privateslot

Definition at line 607 of file recorder_writer.cpp.

{
    if (!d->enabled || !d->canvas)
        return;
 
    // take snapshots only if main window is active
    // else some dialogs like filters may disappear when canvas->image()->lock() is called
    if (qobject_cast<KisMainWindow*>(QApplication::activeWindow()) == nullptr)
        return;
 
    if ((!d->settings.recordIsolateLayerMode) &&
        (d->canvas->image()->isIsolatingLayer() || d->canvas->image()->isIsolatingGroup())) {
        return;
    }
 
    if (!d->imageModified)
        return;
 
    d->imageModified = false;
 
    if (!d->canStartCapture())
        return;
 
    d->searchForFreeWriter();
 
    if (d->freeWriterId == -1)
    {
        Q_EMIT lowPerformanceWarning();
        return;
    }
 
    d->writerPool[d->freeWriterId].inUse = true;
    d->writerPool[d->freeWriterId].thread->setPriority(QThread::HighPriority);
    recorderThreads.incUsedAndNotify();
 
    RecorderImageCopyingJob *job = new RecorderImageCopyingJob(d->canvas->image()->projection(),
                                                               d->canvas->image()->bounds(),
                                                               d->freeWriterId,
                                                               ++d->partIndex);
 
    connect(job,
            SIGNAL(sigImageCopyingDoneWithData(int, int, KisPaintDeviceSP)),
            this,
            SIGNAL(startCapturing(int, int, KisPaintDeviceSP)));
 
    d->canvas->image()->addSpontaneousJob(job);
}

References RecorderWriterManager::Private::canStartCapture(), RecorderWriterManager::Private::canvas, d, RecorderWriterManager::Private::enabled, RecorderWriterManager::Private::freeWriterId, RecorderWriterManager::Private::imageModified, ThreadCounter::incUsedAndNotify(), lowPerformanceWarning(), RecorderWriterManager::Private::partIndex, recorderThreads, RecorderWriterSettings::recordIsolateLayerMode, RecorderWriterManager::Private::searchForFreeWriter(), RecorderWriterManager::Private::settings, startCapturing(), and RecorderWriterManager::Private::writerPool.

onToolChanged

void RecorderWriterManager::onToolChanged ( const QString & toolId )

privateslot

Definition at line 680 of file recorder_writer.cpp.

{
    d->isForceBlackTool = forceBlacklistedTools.contains(toolId);
    d->isActivateBlackTool = activateBlacklistedTools.contains(toolId);
}

References d, RecorderWriterManager::Private::isActivateBlackTool, and RecorderWriterManager::Private::isForceBlackTool.

onToolPrimaryActionActivated

void RecorderWriterManager::onToolPrimaryActionActivated ( bool activated )

privateslot

Definition at line 686 of file recorder_writer.cpp.

{
    d->toolActivated = activated;
}

References d, and RecorderWriterManager::Private::toolActivated.

operator=() [1/2]

RecorderWriterManager & RecorderWriterManager::operator= ( const RecorderWriterManager & )

delete

operator=() [2/2]

RecorderWriterManager & RecorderWriterManager::operator= ( RecorderWriterManager && )

delete

recorderStopWarning

void RecorderWriterManager::recorderStopWarning ( )

signal

setCanvas()

void RecorderWriterManager::setCanvas

(

QPointer< KisCanvas2 >

canvas

)

Definition at line 509 of file recorder_writer.cpp.

{
    // Restart writers if canvas changes
    bool restart = d->timer.isActive();
    if (restart) {
        stop(false);
    }
 
    if (d->canvas) {
        KoToolProxy *proxy = d->canvas->toolProxy();
        KisToolProxy *kritaProxy = dynamic_cast<KisToolProxy*>(proxy);
 
        disconnect(proxy, SIGNAL(toolChanged(QString)), this, SLOT(onToolChanged(QString)));
        disconnect(kritaProxy, SIGNAL(toolPrimaryActionActivated(bool)), this, SLOT(onToolPrimaryActionActivated(bool)));
        disconnect(d->canvas->image(), SIGNAL(sigImageUpdated(QRect)), this, SLOT(onImageModified()));
    }
 
    d->canvas = canvas;
 
    if (d->canvas) {
        KoToolProxy *proxy = d->canvas->toolProxy();
        KisToolProxy *kritaProxy = dynamic_cast<KisToolProxy*>(proxy);
 
        connect(proxy, SIGNAL(toolChanged(QString)), this, SLOT(onToolChanged(QString)),
                Qt::DirectConnection); // need to handle it even if our event loop is not running
        connect(kritaProxy, SIGNAL(toolPrimaryActionActivated(bool)), this, SLOT(onToolPrimaryActionActivated(bool)),
                Qt::DirectConnection);
        connect(d->canvas->image(), SIGNAL(sigImageUpdated(QRect)), this, SLOT(onImageModified()),
                Qt::DirectConnection); // because it spams
    }
 
    if (restart) {
        start(false);
    }
}

References RecorderWriterManager::Private::canvas, d, onImageModified(), onToolChanged(), onToolPrimaryActionActivated(), start(), stop(), and RecorderWriterManager::Private::timer.

setEnabled()

void RecorderWriterManager::setEnabled

(

bool

enabled = false

)

Definition at line 602 of file recorder_writer.cpp.

{
    d->enabled = enabled;
}

References d, and RecorderWriterManager::Private::enabled.

setup()

void RecorderWriterManager::setup

(

const RecorderWriterSettings &

settings

)

Definition at line 545 of file recorder_writer.cpp.

{
    // Restart writers if setup changes
    bool restart = d->timer.isActive();
    if (restart) {
        stop(false);
    }
 
    d->settings = settings;
    d->outputDir.setPath(settings.outputDirectory);
 
    d->partIndex = d->findLastIndex(d->settings.outputDirectory);
 
    if (restart) {
        start(false);
    }
}

References d, RecorderWriterManager::Private::findLastIndex(), RecorderWriterManager::Private::outputDir, RecorderWriterSettings::outputDirectory, RecorderWriterManager::Private::partIndex, RecorderWriterManager::Private::settings, start(), stop(), and RecorderWriterManager::Private::timer.

start()

void RecorderWriterManager::start

(

bool

toggleEnabled = true

)

Definition at line 563 of file recorder_writer.cpp.

{
    if (d->timer.isActive())
        return;
 
    if (!d->canvas)
        return;
 
    d->enabled = true;
    d->imageModified = false;
 
    connect(&d->timer, SIGNAL (timeout()), this, SLOT (onTimer()));
    if (d->settings.realTimeCaptureMode) {
        d->interval = static_cast<int>(1000.0/static_cast<double>(exporterSettings.fps));
    } else {
        d->interval = static_cast<int>(qMax(d->settings.captureInterval, .1) * 1000.0);
    }
    d->enlargeWriterPool();
    d->timer.start(d->interval);
    if (toggleEnabled) {
        Q_EMIT started();
    }
}

References RecorderWriterManager::Private::canvas, RecorderWriterSettings::captureInterval, d, RecorderWriterManager::Private::enabled, RecorderWriterManager::Private::enlargeWriterPool(), exporterSettings, RecorderExportSettings::fps, RecorderWriterManager::Private::imageModified, RecorderWriterManager::Private::interval, onTimer(), RecorderWriterSettings::realTimeCaptureMode, RecorderWriterManager::Private::settings, started(), and RecorderWriterManager::Private::timer.

startCapturing

void RecorderWriterManager::startCapturing ( int writerId, int index, KisPaintDeviceSP device )

signal

started

void RecorderWriterManager::started ( )

signal

stop()

bool RecorderWriterManager::stop

(

bool

toggleEnabled = true

)

Definition at line 587 of file recorder_writer.cpp.

{
    //Check if the timer is active, so that we don't try to clear the writer pool multiple times
    if (!d->timer.isActive())
        return true;
 
    d->timer.stop();
    auto result = d->clearWriterPool();
    recorderThreads.setUsed(0);
    if (toggleEnabled) {
        Q_EMIT stopped();
    }
    return result;
}

References RecorderWriterManager::Private::clearWriterPool(), d, recorderThreads, ThreadCounter::setUsed(), stopped(), and RecorderWriterManager::Private::timer.

stopped

void RecorderWriterManager::stopped ( )

signal

Member Data Documentation

d

Private* const RecorderWriterManager::d

private

Definition at line 144 of file recorder_writer.h.

exporterSettings

const RecorderExportSettings& RecorderWriterManager::exporterSettings

private

Definition at line 145 of file recorder_writer.h.

recorderThreads

ThreadCounter RecorderWriterManager::recorderThreads {}

Definition at line 140 of file recorder_writer.h.

{};

---

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

• plugins/dockers/recorder/recorder_writer.h
• plugins/dockers/recorder/recorder_writer.cpp