RGBE Namespace Reference

Functions
QByteArray	floatToRGBE (const int width, const int height, KisPaintDeviceSP &dev)
void	writeBytesRLE (QByteArray &rleBuffer, quint8 *data, int nBytes)

Function Documentation

floatToRGBE()

QByteArray RGBE::floatToRGBE ( const int width, const int height, KisPaintDeviceSP & dev )

inline

Definition at line 44 of file RGBEExport.cpp.

{
    KisSequentialConstIterator it(dev, {0, 0, width, height});
    QByteArray res;
    res.resize(width * height * 4);
 
    quint8 rgbe[4] = {0, 0, 0, 0};
 
    quint8 *ptr = reinterpret_cast<quint8 *>(res.data());
    while (it.nextPixel()) {
        auto *src = reinterpret_cast<const float *>(it.rawDataConst());
        auto *dst = reinterpret_cast<quint8 *>(ptr);
        float vMax = std::max(src[2], std::max(src[0], src[1]));
        int exp;
 
        if (vMax < 1e-32) {
            rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0;
        } else {
            vMax = frexp(vMax, &exp) * 256.0f / vMax;
            // Clamp negative values
            rgbe[0] = static_cast<quint8>(std::max(src[0], 0.0f) * vMax);
            rgbe[1] = static_cast<quint8>(std::max(src[1], 0.0f) * vMax);
            rgbe[2] = static_cast<quint8>(std::max(src[2], 0.0f) * vMax);
            rgbe[3] = static_cast<quint8>(exp + 128);
        }
 
        std::memcpy(dst, rgbe, 4);
 
        ptr += 4;
    }
 
    return res;
}

References floatToRGBE().

writeBytesRLE()

void RGBE::writeBytesRLE ( QByteArray & rleBuffer, quint8 * data, int nBytes )

inline

Definition at line 78 of file RGBEExport.cpp.

{
    static constexpr int minRunLen = 4;
    int cur = 0;
    int begRun;
    int runCount;
    int oldRunCount;
    int nonRunCount;
 
    quint8 buf[2];
 
    while (cur < nBytes) {
        begRun = cur;
 
        runCount = oldRunCount = 0;
        while ((runCount < minRunLen) && (begRun < nBytes)) {
            begRun += runCount;
            oldRunCount = runCount;
            runCount = 1;
            while ((begRun + runCount < nBytes) && (runCount < 127) && (data[begRun] == data[begRun + runCount])) {
                runCount++;
            }
        }
 
        if ((oldRunCount > 1) && (oldRunCount == begRun - cur)) {
            buf[0] = 128 + oldRunCount;
            buf[1] = data[cur];
            rleBuffer.append(reinterpret_cast<const char *>(buf), sizeof(buf));
            cur = begRun;
        }
 
        while (cur < begRun) {
            nonRunCount = begRun - cur;
            if (nonRunCount > 128) {
                nonRunCount = 128;
            }
            buf[0] = nonRunCount;
            rleBuffer.append(buf[0]);
            rleBuffer.append(reinterpret_cast<const char *>(data + cur), sizeof(data[0]) * nonRunCount);
            cur += nonRunCount;
        }
 
        if (runCount >= minRunLen) {
            buf[0] = 128 + runCount;
            buf[1] = data[begRun];
            rleBuffer.append(reinterpret_cast<const char *>(buf), sizeof(buf));
            cur += runCount;
        }
    }
}

References writeBytesRLE().