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)
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 97 of file recorder_writer.h.

Constructor & Destructor Documentation

RecorderWriterManager() [1/4]

RecorderWriterManager::RecorderWriterManager ( const RecorderExportSettings & es )

explicit

Definition at line 494 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 501 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 640 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 653 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 603 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();
    Q_EMIT startCapturing(d->freeWriterId, ++d->partIndex);
}

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 665 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 671 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 506 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, connect(), d, onImageModified(), onToolChanged(), onToolPrimaryActionActivated(), start(), stop(), and RecorderWriterManager::Private::timer.

setEnabled()

void RecorderWriterManager::setEnabled

(

bool

enabled = false

)

Definition at line 598 of file recorder_writer.cpp.

{
    d->enabled = enabled;
}

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

setup()

void RecorderWriterManager::setup

(

const RecorderWriterSettings &

settings

)

Definition at line 542 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 560 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, connect(), 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 )

signal

started

void RecorderWriterManager::started ( )

signal

stop()

bool RecorderWriterManager::stop

(

bool

toggleEnabled = true

)

Definition at line 584 of file recorder_writer.cpp.

{
    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 141 of file recorder_writer.h.

exporterSettings

const RecorderExportSettings& RecorderWriterManager::exporterSettings

private

Definition at line 142 of file recorder_writer.h.

recorderThreads

ThreadCounter RecorderWriterManager::recorderThreads {}

Definition at line 137 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