RecorderWriterManager::Private Class Reference

Public Member Functions
bool	canStartCapture ()
bool	clearWriterPool ()
void	enlargeWriterPool ()
int	findLastIndex (const QString &directory)
	Private (RecorderWriterManager *q_ptr, ThreadCounter &rt)
void	searchForFreeWriter ()

Public Attributes
QPointer< KisCanvas2 >	canvas
volatile std::atomic_bool	enabled = false
std::atomic_int	freeWriterId = -1
volatile std::atomic_bool	imageModified = false
int	interval = 1
volatile std::atomic_bool	isActivateBlackTool = false
volatile std::atomic_bool	isForceBlackTool = false
QDir	outputDir
int	partIndex = 0
RecorderWriterManager *const	q
ThreadCounter &	recorderThreads
RecorderWriterSettings	settings {}
QTimer	timer
volatile std::atomic_bool	toolActivated = false
WriterPool	writerPool

Detailed Description

Definition at line 350 of file recorder_writer.cpp.

Constructor & Destructor Documentation

Private()

RecorderWriterManager::Private::Private ( RecorderWriterManager * q_ptr, ThreadCounter & rt )

inline

Definition at line 353 of file recorder_writer.cpp.

        : q(q_ptr)
        , recorderThreads(rt)
    {}

Member Function Documentation

canStartCapture()

bool RecorderWriterManager::Private::canStartCapture ( )

inline

Definition at line 487 of file recorder_writer.cpp.

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

References isActivateBlackTool, isForceBlackTool, and toolActivated.

clearWriterPool()

bool RecorderWriterManager::Private::clearWriterPool ( )

inline

Definition at line 400 of file recorder_writer.cpp.

    {
        bool result = true;
        bool alreadyWarn = false;
        bool alreadyErr = false;
 
        for (auto &el : writerPool) {
            if (el.inUse && !el.writer->isActive()) {
                // There's a pending job, but the writer didn't recieve the signal yet
 
                // Wait until all the jobs processes
                canvas->image()->waitForDone();
 
                // Make sure the signals are delivered
                QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
 
                //we can exit the loop, all the signals have been delivered and we don't need to check further
                break;
            }
        }
 
        for (auto &el : writerPool) {
            el.thread->quit();
            el.thread->wait(RecorderConst::waitThreadTimeoutMs);
            disconnect(q, SIGNAL(startCapturing(int, int, KisPaintDeviceSP)), el.writer.get(), SLOT(onCaptureImage(int, int, KisPaintDeviceSP)));
            disconnect(el.writer.get(), SIGNAL(capturingDone(int, bool)), q, SLOT(onCapturingDone(int, bool)));
            if (el.thread->isRunning())
            {
                if (!alreadyWarn) {
                    warnResources << "One of the Recorder WriterPool threads has been blocked and has to be terminated. "
                                  << "Thread Name: " << el.thread->objectName();
                    alreadyWarn = true;
                }
                el.thread->terminate();
                if (!el.thread->wait(RecorderConst::waitThreadTimeoutMs))
                {
                    if (!alreadyErr) {
                        errResources << "Something odd has been happen. Krita was unable to stop one of the Recorder WriterPool Threads. "
                                     << "Thread Name: " << el.thread->objectName();
                        alreadyErr = true;
                    }
                    result = false;
                }
            }
        }
 
        writerPool.clear();
        freeWriterId = -1;
 
        if (!result)
            Q_EMIT q->recorderStopWarning();
 
        return result;
    }

References canvas, errResources, freeWriterId, RecorderWriterManager::onCapturingDone(), q, RecorderWriterManager::recorderStopWarning(), RecorderWriterManager::startCapturing(), RecorderConst::waitThreadTimeoutMs, warnResources, and writerPool.

enlargeWriterPool()

void RecorderWriterManager::Private::enlargeWriterPool ( )

inline

Definition at line 455 of file recorder_writer.cpp.

    {
        writerPool.reserve(recorderThreads.get());
        while (static_cast<int>(recorderThreads.get()) > writerPool.size()) {
            auto newWorkerId = writerPool.size();
            freeWriterId = newWorkerId - 1; // Set the value to the last existing writerEl index ->
                                            // The next call of searchForFreeWriter() will than automatically find newWorkerId
 
            writerPool.append(WriterPoolEl(q, newWorkerId, canvas, settings, outputDir));
 
            auto writerPtr = writerPool[newWorkerId].writer;
            auto threadPtr = writerPool[newWorkerId].thread;
            threadPtr->setObjectName(QString("Krita-Recorder-WriterPool#%1").arg(newWorkerId));
            connect(q, SIGNAL(startCapturing(int, int, KisPaintDeviceSP)), writerPtr.get(), SLOT(onCaptureImage(int, int, KisPaintDeviceSP)));
            connect(writerPtr.get(), SIGNAL(capturingDone(int, bool)), q, SLOT(onCapturingDone(int, bool)));
            writerPtr->moveToThread(threadPtr.get());
            threadPtr->start(QThread::IdlePriority);
        }
    }

References canvas, freeWriterId, ThreadCounter::get(), RecorderWriterManager::onCapturingDone(), outputDir, q, recorderThreads, settings, RecorderWriterManager::startCapturing(), and writerPool.

findLastIndex()

int RecorderWriterManager::Private::findLastIndex ( const QString & directory )

inline

Definition at line 374 of file recorder_writer.cpp.

    {
        QElapsedTimer dbgTimer;
        dbgTimer.start();
 
        QDirIterator dirIterator(directory);
        const QString &extension = RecorderFormatInfo::fileExtension(settings.format);
        const QRegularExpression &snapshotFilePattern = RecorderConst::snapshotFilePatternFor(extension);
 
        int recordIndex = -1;
        while (dirIterator.hasNext()) {
            dirIterator.next();
 
            const QString &fileName = dirIterator.fileName();
            const QRegularExpressionMatch &match = snapshotFilePattern.match(fileName);
            if (match.hasMatch()) {
                int index = match.captured(1).toInt();
                if (recordIndex < index)
                    recordIndex = index;
            }
        }
        dbgTools << "findLastPartNumber for" << directory << ": " << dbgTimer.elapsed() << "ms";
 
        return recordIndex;
    }

References dbgTools, RecorderFormatInfo::fileExtension(), RecorderWriterSettings::format, settings, and RecorderConst::snapshotFilePatternFor().

searchForFreeWriter()

void RecorderWriterManager::Private::searchForFreeWriter ( )

inline

Definition at line 475 of file recorder_writer.cpp.

    {
        auto j = freeWriterId + 1;
        for(auto i = 0; i < writerPool.size(); i++, j++)
        {
            freeWriterId = j % writerPool.size();
            if (writerPool[freeWriterId].thread->isRunning() && !writerPool[freeWriterId].inUse)
                return;
        }
        freeWriterId = -1;
    }

References freeWriterId, and writerPool.

Member Data Documentation

canvas

QPointer<KisCanvas2> RecorderWriterManager::Private::canvas

Definition at line 368 of file recorder_writer.cpp.

enabled

volatile std::atomic_bool RecorderWriterManager::Private::enabled = false

Definition at line 360 of file recorder_writer.cpp.

freeWriterId

std::atomic_int RecorderWriterManager::Private::freeWriterId = -1

Definition at line 366 of file recorder_writer.cpp.

imageModified

volatile std::atomic_bool RecorderWriterManager::Private::imageModified = false

Definition at line 361 of file recorder_writer.cpp.

interval

int RecorderWriterManager::Private::interval = 1

Definition at line 367 of file recorder_writer.cpp.

isActivateBlackTool

volatile std::atomic_bool RecorderWriterManager::Private::isActivateBlackTool = false

Definition at line 363 of file recorder_writer.cpp.

isForceBlackTool

volatile std::atomic_bool RecorderWriterManager::Private::isForceBlackTool = false

Definition at line 362 of file recorder_writer.cpp.

outputDir

QDir RecorderWriterManager::Private::outputDir

Definition at line 372 of file recorder_writer.cpp.

partIndex

int RecorderWriterManager::Private::partIndex = 0

Definition at line 365 of file recorder_writer.cpp.

q

RecorderWriterManager* const RecorderWriterManager::Private::q

Definition at line 358 of file recorder_writer.cpp.

recorderThreads

ThreadCounter& RecorderWriterManager::Private::recorderThreads

Definition at line 359 of file recorder_writer.cpp.

settings

RecorderWriterSettings RecorderWriterManager::Private::settings {}

Definition at line 371 of file recorder_writer.cpp.

{};

timer

QTimer RecorderWriterManager::Private::timer

Definition at line 369 of file recorder_writer.cpp.

toolActivated

volatile std::atomic_bool RecorderWriterManager::Private::toolActivated = false

Definition at line 364 of file recorder_writer.cpp.

writerPool

WriterPool RecorderWriterManager::Private::writerPool

Definition at line 370 of file recorder_writer.cpp.

---

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

• plugins/dockers/recorder/recorder_writer.cpp