RecorderWriter::Private Class Reference

Public Member Functions
quint32	avg (quint32 c1, quint32 c2)
quint32	blendSourceOver (const int alpha, const quint32 source, const quint32 destination)
void	captureImage (KisPaintDeviceSP device)
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)
void	removeFrameTransparency ()
int	writeFrame (int index)

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

Detailed Description

Definition at line 117 of file recorder_writer.cpp.

Constructor & Destructor Documentation

Private() [1/4]

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

inline

Definition at line 120 of file recorder_writer.cpp.

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

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 198 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 226 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()

void RecorderWriter::Private::captureImage ( KisPaintDeviceSP device )

inline

Definition at line 147 of file recorder_writer.cpp.

    {
        KisImageSP image = canvas->image();
 
        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;
    }

References canvas, KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KisImage::colorSpace(), KisPaintDevice::convertTo(), frame, frameResolution, KoColorProfile::getColorPrimaries(), KoColorProfile::getTransferCharacteristics(), KoColorProfile::hasColorants(), KisImage::height(), imageBuffer, imageBufferHeight, imageBufferWidth, Integer8BitsColorDepthID, KisPaintDevice::pixelSize(), PRIMARIES_ITU_R_BT_709_5, KoColorSpace::profile(), KisPaintDevice::readBytes(), RecorderWriterSettings::resolution, RGBAColorModelID, settings, targetCs, TRC_IEC_61966_2_1, and KisImage::width().

halfSizeImageBuffer()

void RecorderWriter::Private::halfSizeImageBuffer ( )

inline

Definition at line 203 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 239 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 ( int index )

inline

Definition at line 260 of file recorder_writer.cpp.

    {
        if (!outputDir->exists() && !outputDir->mkpath(settings->outputDirectory))
            return false;
 
        const QString fileName = QString("%1").arg(index, 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;
        }
 
        bool result = frame.save(filePath, RecorderFormatInfo::fileFormat(settings->format).data(), factor);
        if (!result)
            QFile(filePath).remove(); // remove corrupted frame
        return result;
    }

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

Member Data Documentation

canvas

QPointer<KisCanvas2> RecorderWriter::Private::canvas

Definition at line 131 of file recorder_writer.cpp.

frame

QImage RecorderWriter::Private::frame

Definition at line 135 of file recorder_writer.cpp.

frameResolution

int RecorderWriter::Private::frameResolution = -1

Definition at line 136 of file recorder_writer.cpp.

imageBuffer

QByteArray RecorderWriter::Private::imageBuffer

Definition at line 132 of file recorder_writer.cpp.

imageBufferHeight

int RecorderWriter::Private::imageBufferHeight = 0

Definition at line 134 of file recorder_writer.cpp.

imageBufferWidth

int RecorderWriter::Private::imageBufferWidth = 0

Definition at line 133 of file recorder_writer.cpp.

isActive

bool RecorderWriter::Private::isActive = false

Definition at line 138 of file recorder_writer.cpp.

outputDir

const QDir* RecorderWriter::Private::outputDir

Definition at line 140 of file recorder_writer.cpp.

partIndex

int RecorderWriter::Private::partIndex = 0

Definition at line 137 of file recorder_writer.cpp.

settings

const RecorderWriterSettings* RecorderWriter::Private::settings

Definition at line 139 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 142 of file recorder_writer.cpp.

---

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

• plugins/dockers/recorder/recorder_writer.cpp