RecorderWriter::Private Class Reference

Public Member Functions
quint32	avg (quint32 c1, quint32 c2)
quint32	blendSourceOver (const int alpha, const quint32 source, const quint32 destination)
int	captureImage ()
void	halfSizeImageBuffer ()
Private &	operator= (const Private &)=default
Private &	operator= (Private &&)=delete
	Private ()=delete
	Private (const Private &)=default
	Private (Private &&)=delete
	Private (QPointer< KisCanvas2 > c, const RecorderWriterSettings &s, const QDir &d, RecorderWriterManager *m)
void	removeFrameTransparency ()
int	writeFrame ()

Public Attributes
QPointer< KisCanvas2 >	canvas
QImage	frame
int	frameResolution = -1
QByteArray	imageBuffer
int	imageBufferHeight = 0
int	imageBufferWidth = 0
RecorderWriterManager *	manager
const QDir *	outputDir
int	partIndex = 0
const RecorderWriterSettings *	settings
const KoColorSpace *	targetCs

Detailed Description

Definition at line 127 of file recorder_writer.cpp.

Constructor & Destructor Documentation

Private() [1/4]

RecorderWriter::Private::Private ( QPointer< KisCanvas2 > c, const RecorderWriterSettings & s, const QDir & d, RecorderWriterManager * m )

inline

Definition at line 130 of file recorder_writer.cpp.

        : canvas(c)
        , settings(&s)
        , outputDir(&d)
        , manager(m)
    {}

Private() [2/4]

RecorderWriter::Private::Private ( )

delete

Private() [3/4]

RecorderWriter::Private::Private ( const Private & )

default

Private() [4/4]

RecorderWriter::Private::Private ( Private && )

delete

Member Function Documentation

avg()

quint32 RecorderWriter::Private::avg ( quint32 c1, quint32 c2 )

inline

Definition at line 229 of file recorder_writer.cpp.

    {
        return (((c1 ^ c2) & 0xfefefefeUL) >> 1) + (c1 & c2);
    }

blendSourceOver()

quint32 RecorderWriter::Private::blendSourceOver ( const int alpha, const quint32 source, const quint32 destination )

inline

Definition at line 257 of file recorder_writer.cpp.

    {
        // co = αs x Cs + αb x Cb x (1 – αs)
        // αo = 1, αb = 1
 
        const int inverseAlpha = 255 - alpha;
        return qRgb(
            (alpha * qRed(source) + inverseAlpha * qRed(destination)) >> 8,
            (alpha * qGreen(source) + inverseAlpha * qGreen(destination)) >> 8,
            (alpha * qBlue(source) + inverseAlpha * qBlue(destination)) >> 8
        );
    }

References source().

captureImage()

int RecorderWriter::Private::captureImage ( )

inline

Definition at line 158 of file recorder_writer.cpp.

    {
        KisImageSP image = canvas->image();
 
        // Make sure we can actually capture something right now
        {
            QMutexLocker lock(manager->captureMutex());
            if (manager->canStartCapture()) {
                // we don't want image->barrierLock() because it will wait until
                // the full stroke is finished
                image->immediateLockForReadOnly();
                // Grab the next index while the capture mutex is held
                partIndex = manager->incrementAndGetIndex();
            } else {
                return STATUS_BLOCKED;
            }
        }
 
        // Create detached paint device that can be converted to target colorspace
        KisPaintDeviceSP device = new KisPaintDevice(image->colorSpace());
        device->makeCloneFromRough(image->projection(), image->bounds());
        image->unlock();
 
        const bool needSrgbConversion = [&]() {
            if (image->colorSpace()->colorDepthId() != Integer8BitsColorDepthID
                || image->colorSpace()->colorModelId() != RGBAColorModelID) {
                return true;
            }
            const bool hasPrimaries = image->colorSpace()->profile()->hasColorants();
            const TransferCharacteristics gamma = image->colorSpace()->profile()->getTransferCharacteristics();
            if (hasPrimaries) {
                const ColorPrimaries primaries = image->colorSpace()->profile()->getColorPrimaries();
                if (gamma == TRC_IEC_61966_2_1 && primaries == PRIMARIES_ITU_R_BT_709_5) {
                    return false;
                }
            }
            return true;
        }();
 
        if (targetCs && needSrgbConversion) {
            device->convertTo(targetCs);
        }
 
        // truncate uneven image width/height making it even for subdivided size too
        const quint32 bitmask = ~(0xFFFFFFFFu >> (31 - settings->resolution));
        const quint32 width = image->width() & bitmask;
        const quint32 height = image->height() & bitmask;
        const int bufferSize = device->pixelSize() * width * height;
 
        bool resize = imageBuffer.size() != bufferSize;
        if (resize)
            imageBuffer.resize(bufferSize);
 
        if (resize || frameResolution != settings->resolution) {
            const int divider = 1 << settings->resolution;
            const int outWidth = width / divider;
            const int outHeight = height / divider;
            uchar *outData = reinterpret_cast<uchar *>(imageBuffer.data());
 
            frame = QImage(outData, outWidth, outHeight, QImage::Format_ARGB32);
        }
 
        device->readBytes(reinterpret_cast<quint8 *>(imageBuffer.data()), 0, 0, width, height);
 
        imageBufferWidth = width;
        imageBufferHeight = height;
        return STATUS_OK;
    }

References KisImage::bounds(), RecorderWriterManager::canStartCapture(), canvas, RecorderWriterManager::captureMutex(), KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KisImage::colorSpace(), KisPaintDevice::convertTo(), frame, frameResolution, KoColorProfile::getColorPrimaries(), KoColorProfile::getTransferCharacteristics(), KoColorProfile::hasColorants(), KisImage::height(), imageBuffer, imageBufferHeight, imageBufferWidth, KisImage::immediateLockForReadOnly(), RecorderWriterManager::incrementAndGetIndex(), Integer8BitsColorDepthID, KisPaintDevice::makeCloneFromRough(), manager, partIndex, KisPaintDevice::pixelSize(), PRIMARIES_ITU_R_BT_709_5, KoColorSpace::profile(), KisImage::projection(), KisPaintDevice::readBytes(), RecorderWriterSettings::resolution, RGBAColorModelID, settings, RecorderWriter::STATUS_BLOCKED, RecorderWriter::STATUS_OK, targetCs, TRC_IEC_61966_2_1, KisImage::unlock(), and KisImage::width().

halfSizeImageBuffer()

void RecorderWriter::Private::halfSizeImageBuffer ( )

inline

Definition at line 234 of file recorder_writer.cpp.

    {
        quint32 *buffer = reinterpret_cast<quint32 *>(imageBuffer.data());
        quint32 *out = buffer;
 
        for (int y = 0; y < imageBufferHeight; y += 2) {
            const quint32 *in1 = buffer + y * imageBufferWidth;
            const quint32 *in2 = in1 + imageBufferWidth;
 
            for (int x = 0; x < imageBufferWidth; x += 2) {
                *out = avg(
                    avg(in1[x], in1[x + 1]),
                    avg(in2[x], in2[x + 1])
                );
 
                ++out;
            }
        }
 
        imageBufferWidth /= 2;
        imageBufferHeight /= 2;
    }

References avg(), imageBuffer, imageBufferHeight, and imageBufferWidth.

operator=() [1/2]

Private & RecorderWriter::Private::operator= ( const Private & )

default

operator=() [2/2]

Private & RecorderWriter::Private::operator= ( Private && )

delete

removeFrameTransparency()

void RecorderWriter::Private::removeFrameTransparency ( )

inline

Definition at line 270 of file recorder_writer.cpp.

    {
        const quint32 background = 0xFFFFFFFF;
        quint32 *buffer = reinterpret_cast<quint32 *>(imageBuffer.data());
        const quint32 *end = buffer + imageBufferWidth * imageBufferHeight;
        while (buffer != end) {
            const int alpha = qAlpha(*buffer);
            switch (alpha) {
            case 0xFF: // fully opaque
                break;
            case 0x00: // fully transparent - just replace to background
                *buffer = background;
                break;
            default: // partly transparent - do color blending
                *buffer = blendSourceOver(alpha, *buffer, background);
                break;
            }
            ++buffer;
        }
    }

References blendSourceOver(), imageBuffer, imageBufferHeight, and imageBufferWidth.

writeFrame()

int RecorderWriter::Private::writeFrame ( )

inline

Definition at line 291 of file recorder_writer.cpp.

    {
        if (!outputDir->exists() && !outputDir->mkpath(settings->outputDirectory))
            return STATUS_ERROR;
 
        const QString fileName = QString("%1").arg(partIndex, 7, 10, QLatin1Char('0'));
        const QString &filePath = QString("%1%2.%3").arg(settings->outputDirectory, fileName,
                                                         RecorderFormatInfo::fileExtension(settings->format));
 
        int factor = -1; // default value
        switch (settings->format) {
            case RecorderFormat::JPEG:
                factor = settings->quality; // 0...100
                break;
            case RecorderFormat::PNG:
                factor = qBound(0, 100 - (settings->compression * 10), 100); // 0..10 -> 100..0
                break;
        }
 
        if (!frame.save(filePath, RecorderFormatInfo::fileFormat(settings->format).data(), factor)) {
            QFile(filePath).remove(); // remove corrupted frame
            return STATUS_ERROR;
        }
 
        return STATUS_OK;
    }

References RecorderWriterSettings::compression, RecorderFormatInfo::fileExtension(), RecorderFormatInfo::fileFormat(), RecorderWriterSettings::format, frame, JPEG, outputDir, RecorderWriterSettings::outputDirectory, partIndex, PNG, RecorderWriterSettings::quality, settings, RecorderWriter::STATUS_ERROR, and RecorderWriter::STATUS_OK.

Member Data Documentation

canvas

QPointer<KisCanvas2> RecorderWriter::Private::canvas

Definition at line 142 of file recorder_writer.cpp.

frame

QImage RecorderWriter::Private::frame

Definition at line 146 of file recorder_writer.cpp.

frameResolution

int RecorderWriter::Private::frameResolution = -1

Definition at line 147 of file recorder_writer.cpp.

imageBuffer

QByteArray RecorderWriter::Private::imageBuffer

Definition at line 143 of file recorder_writer.cpp.

imageBufferHeight

int RecorderWriter::Private::imageBufferHeight = 0

Definition at line 145 of file recorder_writer.cpp.

imageBufferWidth

int RecorderWriter::Private::imageBufferWidth = 0

Definition at line 144 of file recorder_writer.cpp.

manager

RecorderWriterManager* RecorderWriter::Private::manager

Definition at line 151 of file recorder_writer.cpp.

outputDir

const QDir* RecorderWriter::Private::outputDir

Definition at line 150 of file recorder_writer.cpp.

partIndex

int RecorderWriter::Private::partIndex = 0

Definition at line 148 of file recorder_writer.cpp.

settings

const RecorderWriterSettings* RecorderWriter::Private::settings

Definition at line 149 of file recorder_writer.cpp.

targetCs

const KoColorSpace* RecorderWriter::Private::targetCs

Initial value:

=
        KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(),
                                                     Integer8BitsColorDepthID.id(),
                                                     KoColorSpaceRegistry::instance()->p709SRGBProfile())

Definition at line 153 of file recorder_writer.cpp.

---

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

• plugins/dockers/recorder/recorder_writer.cpp