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)
void	started ()
void	stopped ()

Public Member Functions
bool	canStartCapture () const
QMutex *	captureMutex ()
int	incrementAndGetIndex ()
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, int status)
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 104 of file recorder_writer.h.

Constructor & Destructor Documentation

RecorderWriterManager() [1/4]

RecorderWriterManager::RecorderWriterManager ( const RecorderExportSettings & es )

explicit

Definition at line 505 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 512 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

canStartCapture()

bool RecorderWriterManager::canStartCapture

(

)

const

Definition at line 614 of file recorder_writer.cpp.

{
    if (d->isForceBlackTool)
        return false;
    if (d->isActivateBlackTool && d->toolActivated)
        return false;
    return true;
}

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

captureMutex()

QMutex * RecorderWriterManager::captureMutex

(

)

Definition at line 628 of file recorder_writer.cpp.

{
    return &d->captureMutex;
}

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

frameWriteFailed

void RecorderWriterManager::frameWriteFailed ( )

signal

incrementAndGetIndex()

int RecorderWriterManager::incrementAndGetIndex

(

)

Definition at line 623 of file recorder_writer.cpp.

{
    return ++d->partIndex;
}

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

lowPerformanceWarning

void RecorderWriterManager::lowPerformanceWarning ( )

signal

onCapturingDone

void RecorderWriterManager::onCapturingDone ( int workerId, int status )

privateslot

Definition at line 670 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 (status == RecorderWriter::STATUS_ERROR) {
        stop();
        Q_EMIT frameWriteFailed();
    }
}

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

onImageModified

void RecorderWriterManager::onImageModified ( )

privateslot

Definition at line 683 of file recorder_writer.cpp.

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

References 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 633 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 (!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);
}

References canStartCapture(), RecorderWriterManager::Private::canvas, d, RecorderWriterManager::Private::enabled, RecorderWriterManager::Private::freeWriterId, RecorderWriterManager::Private::imageModified, ThreadCounter::incUsedAndNotify(), lowPerformanceWarning(), 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 695 of file recorder_writer.cpp.

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

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

onToolPrimaryActionActivated

void RecorderWriterManager::onToolPrimaryActionActivated ( bool activated )

privateslot

Definition at line 702 of file recorder_writer.cpp.

{
    QMutexLocker lock(&d->captureMutex);
    d->toolActivated = activated;
}

References RecorderWriterManager::Private::captureMutex, 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 517 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 609 of file recorder_writer.cpp.

{
    d->enabled = enabled;
}

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

setup()

void RecorderWriterManager::setup

(

const RecorderWriterSettings &

settings

)

Definition at line 553 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 571 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 )

signal

started

void RecorderWriterManager::started ( )

signal

stop()

bool RecorderWriterManager::stop

(

bool

toggleEnabled = true

)

Definition at line 595 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 162 of file recorder_writer.h.

exporterSettings

const RecorderExportSettings& RecorderWriterManager::exporterSettings

private

Definition at line 163 of file recorder_writer.h.

recorderThreads

ThreadCounter RecorderWriterManager::recorderThreads {}

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