Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 589 insertions, 0 deletions

diff --git a/kimgio/rgb.cpp b/kimgio/rgb.cpp
new file mode 100644
index 000000000..2e62f4f6f
--- /dev/null
+++ b/kimgio/rgb.cpp
@@ -0,0 +1,589 @@
+// kimgio module for SGI images
+//
+// Copyright (C) 2004  Melchior FRANZ  <mfranz@kde.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the Lesser GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+
+
+/* this code supports:
+ * reading:
+ *     everything, except images with 1 dimension or images with
+ *     mapmode != NORMAL (e.g. dithered); Images with 16 bit
+ *     precision or more than 4 layers are stripped down.
+ * writing:
+ *     Run Length Encoded (RLE) or Verbatim (uncompressed)
+ *     (whichever is smaller)
+ *
+ * Please report if you come across rgb/rgba/sgi/bw files that aren't
+ * recognized. Also report applications that can't deal with images
+ * saved by this filter.
+ */
+
+
+#include "rgb.h"
+#include <qimage.h>
+#include <kdebug.h>
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+KDE_EXPORT void kimgio_rgb_read(QImageIO *io)
+{
+	SGIImage sgi(io);
+	QImage img;
+
+	if (!sgi.readImage(img)) {
+		io->setImage(0);
+		io->setStatus(-1);
+		return;
+	}
+
+	io->setImage(img);
+	io->setStatus(0);
+}
+
+
+KDE_EXPORT void kimgio_rgb_write(QImageIO *io)
+{
+	SGIImage sgi(io);
+	QImage img = io->image();
+
+	if (!sgi.writeImage(img))
+		io->setStatus(-1);
+
+	io->setStatus(0);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+SGIImage::SGIImage(QImageIO *io) :
+	m_io(io),
+	m_starttab(0),
+	m_lengthtab(0)
+{
+	m_dev = io->ioDevice();
+	m_stream.setDevice(m_dev);
+}
+
+
+SGIImage::~SGIImage()
+{
+	delete[] m_starttab;
+	delete[] m_lengthtab;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+bool SGIImage::getRow(uchar *dest)
+{
+	int n, i;
+	if (!m_rle) {
+		for (i = 0; i < m_xsize; i++) {
+			if (m_pos >= m_data.end())
+				return false;
+			dest[i] = uchar(*m_pos);
+			m_pos += m_bpc;
+		}
+		return true;
+	}
+
+	for (i = 0; i < m_xsize;) {
+		if (m_bpc == 2)
+			m_pos++;
+		n = *m_pos & 0x7f;
+		if (!n)
+			break;
+
+		if (*m_pos++ & 0x80) {
+			for (; i < m_xsize && n--; i++) {
+				*dest++ = *m_pos;
+				m_pos += m_bpc;
+			}
+		} else {
+			for (; i < m_xsize && n--; i++)
+				*dest++ = *m_pos;
+
+			m_pos += m_bpc;
+		}
+	}
+	return i == m_xsize;
+}
+
+
+bool SGIImage::readData(QImage& img)
+{
+	QRgb *c;
+	Q_UINT32 *start = m_starttab;
+	QByteArray lguard(m_xsize);
+	uchar *line = (uchar *)lguard.data();
+	unsigned x, y;
+
+	if (!m_rle)
+		m_pos = m_data.begin();
+
+	for (y = 0; y < m_ysize; y++) {
+		if (m_rle)
+			m_pos = m_data.begin() + *start++;
+		if (!getRow(line))
+			return false;
+		c = (QRgb *)img.scanLine(m_ysize - y - 1);
+		for (x = 0; x < m_xsize; x++, c++)
+			*c = qRgb(line[x], line[x], line[x]);
+	}
+
+	if (m_zsize == 1)
+		return true;
+
+	if (m_zsize != 2) {
+		for (y = 0; y < m_ysize; y++) {
+			if (m_rle)
+				m_pos = m_data.begin() + *start++;
+			if (!getRow(line))
+				return false;
+			c = (QRgb *)img.scanLine(m_ysize - y - 1);
+			for (x = 0; x < m_xsize; x++, c++)
+				*c = qRgb(qRed(*c), line[x], line[x]);
+		}
+
+		for (y = 0; y < m_ysize; y++) {
+			if (m_rle)
+				m_pos = m_data.begin() + *start++;
+			if (!getRow(line))
+				return false;
+			c = (QRgb *)img.scanLine(m_ysize - y - 1);
+			for (x = 0; x < m_xsize; x++, c++)
+				*c = qRgb(qRed(*c), qGreen(*c), line[x]);
+		}
+
+		if (m_zsize == 3)
+			return true;
+	}
+
+	for (y = 0; y < m_ysize; y++) {
+		if (m_rle)
+			m_pos = m_data.begin() + *start++;
+		if (!getRow(line))
+			return false;
+		c = (QRgb *)img.scanLine(m_ysize - y - 1);
+		for (x = 0; x < m_xsize; x++, c++)
+			*c = qRgba(qRed(*c), qGreen(*c), qBlue(*c), line[x]);
+	}
+
+	return true;
+}
+
+
+bool SGIImage::readImage(QImage& img)
+{
+	Q_INT8 u8;
+	Q_INT16 u16;
+	Q_INT32 u32;
+
+	kdDebug(399) << "reading '" << m_io->fileName() << '\'' << endl;
+
+	// magic
+	m_stream >> u16;
+	if (u16 != 0x01da)
+		return false;
+
+	// verbatim/rle
+	m_stream >> m_rle;
+	kdDebug(399) << (m_rle ? "RLE" : "verbatim") << endl;
+	if (m_rle > 1)
+		return false;
+
+	// bytes per channel
+	m_stream >> m_bpc;
+	kdDebug(399) << "bytes per channel: " << int(m_bpc) << endl;
+	if (m_bpc == 1)
+		;
+	else if (m_bpc == 2)
+		kdDebug(399) << "dropping least significant byte" << endl;
+	else
+		return false;
+
+	// number of dimensions
+	m_stream >> m_dim;
+	kdDebug(399) << "dimensions: " << m_dim << endl;
+	if (m_dim < 1 || m_dim > 3)
+		return false;
+
+	m_stream >> m_xsize >> m_ysize >> m_zsize >> m_pixmin >> m_pixmax >> u32;
+	kdDebug(399) << "x: " << m_xsize << endl;
+	kdDebug(399) << "y: " << m_ysize << endl;
+	kdDebug(399) << "z: " << m_zsize << endl;
+
+	// name
+	m_stream.readRawBytes(m_imagename, 80);
+	m_imagename[79] = '\0';
+	m_io->setDescription(m_imagename);
+
+	m_stream >> m_colormap;
+	kdDebug(399) << "colormap: " << m_colormap << endl;
+	if (m_colormap != NORMAL)
+		return false;		// only NORMAL supported
+
+	for (int i = 0; i < 404; i++)
+		m_stream >> u8;
+
+	if (m_dim == 1) {
+		kdDebug(399) << "1-dimensional images aren't supported yet" << endl;
+		return false;
+	}
+
+	if( m_stream.atEnd())
+		return false;
+
+	m_numrows = m_ysize * m_zsize;
+
+	if (!img.create(m_xsize, m_ysize, 32)) {
+		kdDebug(399) << "cannot create image" << endl;
+		return false;
+	}
+
+	if (m_zsize == 2 || m_zsize == 4)
+		img.setAlphaBuffer(true);
+	else if (m_zsize > 4)
+		kdDebug(399) << "using first 4 of " << m_zsize << " channels" << endl;
+
+	if (m_rle) {
+		uint l;
+		m_starttab = new Q_UINT32[m_numrows];
+		for (l = 0; !m_stream.atEnd() && l < m_numrows; l++) {
+			m_stream >> m_starttab[l];
+			m_starttab[l] -= 512 + m_numrows * 2 * sizeof(Q_UINT32);
+		}
+
+		m_lengthtab = new Q_UINT32[m_numrows];
+		for (l = 0; l < m_numrows; l++)
+			m_stream >> m_lengthtab[l];
+	}
+
+	m_data = m_dev->readAll();
+
+	// sanity check
+	if (m_rle)
+		for (uint o = 0; o < m_numrows; o++)
+			// don't change to greater-or-equal!
+			if (m_starttab[o] + m_lengthtab[o] > m_data.size()) {
+				kdDebug(399) << "image corrupt (sanity check failed)" << endl;
+				return false;
+			}
+
+	if (!readData(img)) {
+		kdDebug(399) << "image corrupt (incomplete scanline)" << endl;
+		return false;
+	}
+
+	return true;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+// TODO remove; for debugging purposes only
+void RLEData::print(QString desc) const
+{
+	QString s = desc + ": ";
+	for (uint i = 0; i < size(); i++)
+		s += QString::number(at(i)) + ",";
+	kdDebug() << "--- " << s << endl;
+}
+
+
+void RLEData::write(QDataStream& s)
+{
+	for (unsigned i = 0; i < size(); i++)
+		s << at(i);
+}
+
+
+bool RLEData::operator<(const RLEData& b) const
+{
+	uchar ac, bc;
+	for (unsigned i = 0; i < QMIN(size(), b.size()); i++) {
+		ac = at(i);
+		bc = b[i];
+		if (ac != bc)
+			return ac < bc;
+	}
+	return size() < b.size();
+}
+
+
+uint RLEMap::insert(const uchar *d, uint l)
+{
+	RLEData data = RLEData(d, l, m_offset);
+	Iterator it = find(data);
+	if (it != end())
+		return it.data();
+
+	m_offset += l;
+	return QMap<RLEData, uint>::insert(data, m_counter++).data();
+}
+
+
+QPtrVector<RLEData> RLEMap::vector()
+{
+	QPtrVector<RLEData> v(size());
+	for (Iterator it = begin(); it != end(); ++it)
+		v.insert(it.data(), &it.key());
+
+	return v;
+}
+
+
+uchar SGIImage::intensity(uchar c)
+{
+	if (c < m_pixmin)
+		m_pixmin = c;
+	if (c > m_pixmax)
+		m_pixmax = c;
+	return c;
+}
+
+
+uint SGIImage::compact(uchar *d, uchar *s)
+{
+	uchar *dest = d, *src = s, patt, *t, *end = s + m_xsize;
+	int i, n;
+	while (src < end) {
+		for (n = 0, t = src; t + 2 < end && !(*t == t[1] && *t == t[2]); t++)
+			n++;
+
+		while (n) {
+			i = n > 126 ? 126 : n;
+			n -= i;
+			*dest++ = 0x80 | i;
+			while (i--)
+				*dest++ = *src++;
+		}
+
+		if (src == end)
+			break;
+
+		patt = *src++;
+		for (n = 1; src < end && *src == patt; src++)
+			n++;
+
+		while (n) {
+			i = n > 126 ? 126 : n;
+			n -= i;
+			*dest++ = i;
+			*dest++ = patt;
+		}
+	}
+	*dest++ = 0;
+	return dest - d;
+}
+
+
+bool SGIImage::scanData(const QImage& img)
+{
+	Q_UINT32 *start = m_starttab;
+	QCString lineguard(m_xsize * 2);
+	QCString bufguard(m_xsize);
+	uchar *line = (uchar *)lineguard.data();
+	uchar *buf = (uchar *)bufguard.data();
+	QRgb *c;
+	unsigned x, y;
+	uint len;
+
+	for (y = 0; y < m_ysize; y++) {
+		c = reinterpret_cast<QRgb *>(img.scanLine(m_ysize - y - 1));
+		for (x = 0; x < m_xsize; x++)
+			buf[x] = intensity(qRed(*c++));
+		len = compact(line, buf);
+		*start++ = m_rlemap.insert(line, len);
+	}
+
+	if (m_zsize == 1)
+		return true;
+
+	if (m_zsize != 2) {
+		for (y = 0; y < m_ysize; y++) {
+			c = reinterpret_cast<QRgb *>(img.scanLine(m_ysize - y - 1));
+			for (x = 0; x < m_xsize; x++)
+				buf[x] = intensity(qGreen(*c++));
+			len = compact(line, buf);
+			*start++ = m_rlemap.insert(line, len);
+		}
+
+		for (y = 0; y < m_ysize; y++) {
+			c = reinterpret_cast<QRgb *>(img.scanLine(m_ysize - y - 1));
+			for (x = 0; x < m_xsize; x++)
+				buf[x] = intensity(qBlue(*c++));
+			len = compact(line, buf);
+			*start++ = m_rlemap.insert(line, len);
+		}
+
+		if (m_zsize == 3)
+			return true;
+	}
+
+	for (y = 0; y < m_ysize; y++) {
+		c = reinterpret_cast<QRgb *>(img.scanLine(m_ysize - y - 1));
+		for (x = 0; x < m_xsize; x++)
+			buf[x] = intensity(qAlpha(*c++));
+		len = compact(line, buf);
+		*start++ = m_rlemap.insert(line, len);
+	}
+
+	return true;
+}
+
+
+void SGIImage::writeHeader()
+{
+	m_stream << Q_UINT16(0x01da);
+	m_stream << m_rle << m_bpc << m_dim;
+	m_stream << m_xsize << m_ysize << m_zsize;
+	m_stream << m_pixmin << m_pixmax;
+	m_stream << Q_UINT32(0);
+
+	uint i;
+	QString desc = m_io->description();
+	kdDebug(399) << "Description: " << desc << endl;
+	desc.truncate(79);
+
+	for (i = 0; i < desc.length(); i++)
+		m_imagename[i] = desc.latin1()[i];
+	for (; i < 80; i++)
+		m_imagename[i] = '\0';
+	m_stream.writeRawBytes(m_imagename, 80);
+
+	m_stream << m_colormap;
+	for (i = 0; i < 404; i++)
+		m_stream << Q_UINT8(0);
+}
+
+
+void SGIImage::writeRle()
+{
+	m_rle = 1;
+	kdDebug(399) << "writing RLE data" << endl;
+	writeHeader();
+	uint i;
+
+	// write start table
+	for (i = 0; i < m_numrows; i++)
+		m_stream << Q_UINT32(m_rlevector[m_starttab[i]]->offset());
+
+	// write length table
+	for (i = 0; i < m_numrows; i++)
+		m_stream << Q_UINT32(m_rlevector[m_starttab[i]]->size());
+
+	// write data
+	for (i = 0; i < m_rlevector.size(); i++)
+		m_rlevector[i]->write(m_stream);
+}
+
+
+void SGIImage::writeVerbatim(const QImage& img)
+{
+	m_rle = 0;
+	kdDebug(399) << "writing verbatim data" << endl;
+	writeHeader();
+
+	QRgb *c;
+	unsigned x, y;
+
+	for (y = 0; y < m_ysize; y++) {
+		c = reinterpret_cast<QRgb *>(img.scanLine(m_ysize - y - 1));
+		for (x = 0; x < m_xsize; x++)
+			m_stream << Q_UINT8(qRed(*c++));
+	}
+
+	if (m_zsize == 1)
+		return;
+
+	if (m_zsize != 2) {
+		for (y = 0; y < m_ysize; y++) {
+			c = reinterpret_cast<QRgb *>(img.scanLine(m_ysize - y - 1));
+			for (x = 0; x < m_xsize; x++)
+				m_stream << Q_UINT8(qGreen(*c++));
+		}
+
+		for (y = 0; y < m_ysize; y++) {
+			c = reinterpret_cast<QRgb *>(img.scanLine(m_ysize - y - 1));
+			for (x = 0; x < m_xsize; x++)
+				m_stream << Q_UINT8(qBlue(*c++));
+		}
+
+		if (m_zsize == 3)
+			return;
+	}
+
+	for (y = 0; y < m_ysize; y++) {
+		c = reinterpret_cast<QRgb *>(img.scanLine(m_ysize - y - 1));
+		for (x = 0; x < m_xsize; x++)
+			m_stream << Q_UINT8(qAlpha(*c++));
+	}
+}
+
+
+bool SGIImage::writeImage(QImage& img)
+{
+	kdDebug(399) << "writing '" << m_io->fileName() << '\'' << endl;
+
+	if (img.allGray())
+		m_dim = 2, m_zsize = 1;
+	else
+		m_dim = 3, m_zsize = 3;
+
+	if (img.hasAlphaBuffer())
+		m_dim = 3, m_zsize++;
+
+	img = img.convertDepth(32);
+	if (img.isNull()) {
+		kdDebug(399) << "can't convert image to depth 32" << endl;
+		return false;
+	}
+
+	m_bpc = 1;
+	m_xsize = img.width();
+	m_ysize = img.height();
+	m_pixmin = ~0;
+	m_pixmax = 0;
+	m_colormap = NORMAL;
+
+	m_numrows = m_ysize * m_zsize;
+
+	m_starttab = new Q_UINT32[m_numrows];
+	m_rlemap.setBaseOffset(512 + m_numrows * 2 * sizeof(Q_UINT32));
+
+	if (!scanData(img)) {
+		kdDebug(399) << "this can't happen" << endl;
+		return false;
+	}
+
+	m_rlevector = m_rlemap.vector();
+
+	long verbatim_size = m_numrows * m_xsize;
+	long rle_size = m_numrows * 2 * sizeof(Q_UINT32);
+	for (uint i = 0; i < m_rlevector.size(); i++)
+		rle_size += m_rlevector[i]->size();
+
+	kdDebug(399) << "minimum intensity: " << m_pixmin << endl;
+	kdDebug(399) << "maximum intensity: " << m_pixmax << endl;
+	kdDebug(399) << "saved scanlines: " << m_numrows - m_rlemap.size() << endl;
+	kdDebug(399) << "total savings: " << (verbatim_size - rle_size) << " bytes" << endl;
+	kdDebug(399) << "compression: " << (rle_size * 100.0 / verbatim_size) << '%' << endl;
+
+	if (verbatim_size <= rle_size || m_io->quality() > 50)
+		writeVerbatim(img);
+	else
+		writeRle();
+	return true;
+}
+
+