KisZip Namespace Reference

Functions
int	compress (const char *input, int unpacked_len, char *dst, int maxout)
QByteArray	compress (const QByteArray &data)
QByteArray	decompress (const QByteArray &data, int expected_length)
QByteArray	psd_unzip_with_prediction (const QByteArray &src, int dst_len, int row_size, int color_depth)
template<typename T >
void	psd_unzip_with_prediction (QByteArray &dst_buf, int row_size)
template<>
void	psd_unzip_with_prediction< uint16_t > (QByteArray &dst_buf, const int row_size)
template<>
void	psd_unzip_with_prediction< uint8_t > (QByteArray &dst_buf, const int row_size)
int	psd_unzip_without_prediction (const char *src, int packed_len, char *dst, int unpacked_len)
QByteArray	psd_zip_with_prediction (const QByteArray &src, int row_size, int color_depth)
template<typename T >
void	psd_zip_with_prediction (QByteArray &dst_buf, int row_size)
template<>
void	psd_zip_with_prediction< uint16_t > (QByteArray &dst_buf, const int row_size)
template<>
void	psd_zip_with_prediction< uint8_t > (QByteArray &dst_buf, const int row_size)

Function Documentation

compress() [1/2]

int KisZip::compress	(	const char *	input,
		int	unpacked_len,
		char *	dst,
		int	maxout )

Definition at line 152 of file compression.cpp.

{
    z_stream stream{};
    int state;
 
    stream.data_type = Z_BINARY;
    stream.next_in = const_cast<Bytef *>(reinterpret_cast<const Bytef *>(input));
    stream.avail_in = static_cast<uInt>(unpacked_len);
    stream.next_out = reinterpret_cast<Bytef *>(dst);
    stream.avail_out = static_cast<uInt>(maxout);
 
    dbgFile << "Expected unpacked length:" << unpacked_len << ", maxout:" << maxout;
 
    if (deflateInit(&stream, -1) != Z_OK) {
        dbgFile << "Failed deflate initialization";
        return 0;
    }
 
    int flush = Z_PARTIAL_FLUSH;
 
    do {
        state = deflate(&stream, flush);
        if (state == Z_STREAM_END) {
            dbgFile << "Finished deflating";
            flush = Z_FINISH;
        } else if (state != Z_OK) {
            dbgFile << "Error deflating" << state << stream.msg;
            break;
        }
    } while (stream.avail_in > 0);
 
    if (state != Z_OK || stream.avail_in > 0) {
        dbgFile << "Failed deflating" << state << stream.msg;
        return 0;
    }
 
    dbgFile << "Success, deflated size:" << stream.total_out;
 
    return static_cast<int>(stream.total_out);
}

References dbgFile.

compress() [2/2]

QByteArray KisZip::compress

(

const QByteArray &

data

)

Definition at line 193 of file compression.cpp.

{
    QByteArray output(data.length() * 4, '\0');
    const int result = KisZip::compress(data.constData(), data.size(), output.data(), output.size());
    output.resize(result);
    return output;
}

References compress().

decompress()

QByteArray KisZip::decompress	(	const QByteArray &	data,
		int	expected_length )

Definition at line 365 of file compression.cpp.

{
    QByteArray output(expected_length, '\0');
    const int result = psd_unzip_without_prediction(data.constData(), data.size(), output.data(), expected_length);
    if (result == 0)
        return QByteArray();
    else
        return output;
}

References psd_unzip_without_prediction().

psd_unzip_with_prediction() [1/2]

QByteArray KisZip::psd_unzip_with_prediction	(	const QByteArray &	src,
		int	dst_len,
		int	row_size,
		int	color_depth )

Definition at line 285 of file compression.cpp.

{
    QByteArray dst_buf = Compression::uncompress(dst_len, src, psd_compression_type::ZIP);
 
    if (dst_buf.size() == 0)
        return {};
 
    if (color_depth == 32) {
        // Placeholded for future implementation.
        errKrita << "Unsupported bit depth for prediction";
        return {};
    } else if (color_depth == 16) {
        psd_unzip_with_prediction<quint16>(dst_buf, row_size);
    } else {
        psd_unzip_with_prediction<quint8>(dst_buf, row_size);
    }
 
    return dst_buf;
}

References errKrita, Compression::uncompress(), and ZIP.

psd_unzip_with_prediction() [2/2]

template<typename T >

void KisZip::psd_unzip_with_prediction ( QByteArray & dst_buf, int row_size )

inline

psd_unzip_with_prediction< uint16_t >()

template<>

void KisZip::psd_unzip_with_prediction< uint16_t > ( QByteArray & dst_buf, const int row_size )

inline

Definition at line 267 of file compression.cpp.

{
    auto *buf = reinterpret_cast<uint8_t *>(dst_buf.data());
    int len = 0;
    int dst_len = dst_buf.size();
 
    while (dst_len > 0) {
        len = row_size;
        while (--len) {
            buf[2] += buf[0] + ((buf[1] + buf[3]) >> 8);
            buf[3] += buf[1];
            buf += 2;
        }
        buf += 2;
        dst_len -= row_size * 2;
    }
}

psd_unzip_with_prediction< uint8_t >()

template<>

void KisZip::psd_unzip_with_prediction< uint8_t > ( QByteArray & dst_buf, const int row_size )

inline

Definition at line 249 of file compression.cpp.

{
    auto *buf = reinterpret_cast<uint8_t *>(dst_buf.data());
    int len = 0;
    int dst_len = dst_buf.size();
 
    while (dst_len > 0) {
        len = row_size;
        while (--len) {
            *(buf + 1) += *buf;
            buf++;
        }
        buf++;
        dst_len -= row_size;
    }
}

psd_unzip_without_prediction()

int KisZip::psd_unzip_without_prediction	(	const char *	src,
		int	packed_len,
		char *	dst,
		int	unpacked_len )

Definition at line 208 of file compression.cpp.

{
    z_stream stream{};
    int state;
 
    stream.data_type = Z_BINARY;
    stream.next_in = const_cast<Bytef *>(reinterpret_cast<const Bytef *>(src));
    stream.avail_in = static_cast<uInt>(packed_len);
    stream.next_out = reinterpret_cast<Bytef *>(dst);
    stream.avail_out = static_cast<uInt>(unpacked_len);
 
    if (inflateInit(&stream) != Z_OK)
        return 0;
 
    int flush = Z_PARTIAL_FLUSH;
 
    do {
        state = inflate(&stream, flush);
        if (state == Z_STREAM_END) {
            dbgFile << "Finished inflating";
            break;
        } else if (state == Z_DATA_ERROR) {
            dbgFile << "Error inflating" << state << stream.msg;
            if (inflateSync(&stream) != Z_OK)
                return 0;
            continue;
        }
    } while (stream.avail_out > 0);
 
    if ((state != Z_STREAM_END && state != Z_OK) || stream.avail_out > 0) {
        dbgFile << "Failed inflating" << state << stream.msg;
        return 0;
    }
 
    return static_cast<int>(stream.total_out);
}

References dbgFile.

psd_zip_with_prediction() [1/2]

QByteArray KisZip::psd_zip_with_prediction	(	const QByteArray &	src,
		int	row_size,
		int	color_depth )

Definition at line 349 of file compression.cpp.

{
    QByteArray dst_buf(src);
    if (color_depth == 32) {
        // Placeholded for future implementation.
        errKrita << "Unsupported bit depth for prediction";
        return {};
    } else if (color_depth == 16) {
        psd_zip_with_prediction<quint16>(dst_buf, row_size);
    } else {
        psd_zip_with_prediction<quint8>(dst_buf, row_size);
    }
 
    return Compression::compress(dst_buf, psd_compression_type::ZIP);
}

References Compression::compress(), errKrita, and ZIP.

psd_zip_with_prediction() [2/2]

template<typename T >

void KisZip::psd_zip_with_prediction ( QByteArray & dst_buf, int row_size )

inline

psd_zip_with_prediction< uint16_t >()

template<>

void KisZip::psd_zip_with_prediction< uint16_t > ( QByteArray & dst_buf, const int row_size )

inline

Definition at line 331 of file compression.cpp.

{
    auto *buf = reinterpret_cast<uint8_t *>(dst_buf.data());
    int len = 0;
    int dst_len = dst_buf.size();
 
    while (dst_len > 0) {
        len = row_size;
        while (--len) {
            buf[2] -= buf[0] + ((buf[1] + buf[3]) >> 8);
            buf[3] -= buf[1];
            buf += 2;
        }
        buf += 2;
        dst_len -= row_size * 2;
    }
}

psd_zip_with_prediction< uint8_t >()

template<>

void KisZip::psd_zip_with_prediction< uint8_t > ( QByteArray & dst_buf, const int row_size )

inline

Definition at line 313 of file compression.cpp.

{
    auto *buf = reinterpret_cast<uint8_t *>(dst_buf.data());
    int len = 0;
    int dst_len = dst_buf.size();
 
    while (dst_len > 0) {
        len = row_size;
        while (--len) {
            *(buf + 1) -= *buf;
            buf++;
        }
        buf++;
        dst_len -= row_size;
    }
}