KisRLE Namespace Reference

Functions
QByteArray	compress (const QByteArray &data)
int	compress (const QByteArray &src, QByteArray &dst)
QByteArray	decompress (const QByteArray &input, int unpacked_len)

Function Documentation

compress() [1/2]

QByteArray KisRLE::compress

(

const QByteArray &

data

)

Definition at line 77 of file compression.cpp.

{
    QByteArray output;
    const int result = KisRLE::compress(data, output);
    if (result <= 0)
        return QByteArray();
    else
        return output;
}

References compress().

compress() [2/2]

int KisRLE::compress	(	const QByteArray &	src,
		QByteArray &	dst )

Definition at line 23 of file compression.cpp.

{
    int length = src.size();
    dst.resize(length * 2);
    dst.fill(0, length * 2);
 
    int remaining = length;
    quint8 i, j;
    quint32 dest_ptr = 0;
    const char *start = src.constData();
 
    length = 0;
    while (remaining > 0) {
        /* Look for characters matching the first */
        i = 0;
        while ((i < 128) && (remaining - i > 0) && (start[0] == start[i]))
            i++;
 
        if (i > 1) /* Match found */
        {
            dst[dest_ptr++] = static_cast<char>(-(i - 1));
            dst[dest_ptr++] = *start;
 
            start += i;
            remaining -= i;
            length += 2;
        } else { /* Look for characters different from the previous */
            i = 0;
            while ((i < 128) && (remaining - (i + 1) > 0) && (start[i] != start[(i + 1)] || remaining - (i + 2) <= 0 || start[i] != start[(i + 2)]))
                i++;
 
            /* If there's only 1 remaining, the previous WHILE stmt doesn't
             catch it */
 
            if (remaining == 1) {
                i = 1;
            }
 
            if (i > 0) /* Some distinct ones found */
            {
                dst[dest_ptr++] = static_cast<char>(i - 1U);
                for (j = 0; j < i; j++) {
                    dst[dest_ptr++] = start[j];
                }
                start += i;
                remaining -= i;
                length += i + 1;
            }
        }
    }
    dst.resize(length);
    return length;
}

References length().

decompress()

QByteArray KisRLE::decompress	(	const QByteArray &	input,
		int	unpacked_len )

Definition at line 87 of file compression.cpp.

{
    QByteArray output;
    output.resize(unpacked_len);
 
    const auto *src = input.cbegin();
    auto *dst = output.begin();
 
    while (src < input.end() && dst < output.end()) {
        // NOLINTNEXTLINE(*-reinterpret-cast,readability-identifier-length)
        const int8_t n = *reinterpret_cast<const int8_t *>(src);
        src += 1;
 
        if (n >= 0) { // copy next n+1 chars
            const int bytes = 1 + n;
            if (src + bytes > input.cend()) {
                errFile << "Input buffer exhausted in replicate of" << bytes << "chars, left" << (input.cend() - src);
                return {};
            }
            if (dst + bytes > output.end()) {
                errFile << "Overrun in packbits replicate of" << bytes << "chars, left" << (output.end() - dst);
                return {};
            }
            std::copy_n(src, bytes, dst);
            src += bytes;
            dst += bytes;
        } else if (n >= -127 && n <= -1) { // replicate next char -n+1 times
            const int bytes = 1 - n;
            if (src >= input.cend()) {
                errFile << "Input buffer exhausted in copy";
                return {};
            }
            if (dst + bytes > output.end()) {
                errFile << "Output buffer exhausted in copy of" << bytes << "chars, left" << (output.end() - dst);
                return {};
            }
            const auto byte = *src;
            std::fill_n(dst, bytes, byte);
            src += 1;
            dst += bytes;
        } else if (n == -128) {
            continue;
        }
    }
 
    if (dst < output.end()) {
        errFile << "Packbits decode - unpack left" << (output.end() - dst);
        std::fill(dst, output.end(), 0);
    }
 
    // If the input line was odd width, there's a padding byte
    if (src + 1 < input.cend()) {
        QByteArray leftovers;
        leftovers.resize(static_cast<int>(input.cend() - src));
        std::copy(src, input.cend(), leftovers.begin());
        errFile << "Packbits decode - pack left" << leftovers.size() << leftovers.toHex();
    }
 
    return output;
}

References errFile.