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, 282 insertions, 0 deletions

diff --git a/kimgio/psd.cpp b/kimgio/psd.cpp
new file mode 100644
index 000000000..202fbacb4
--- /dev/null
+++ b/kimgio/psd.cpp
@@ -0,0 +1,282 @@
+/* This file is part of the KDE project
+   Copyright (C) 2003 Ignacio Castaņo <castano@ludicon.com>
+
+   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 is based on Thacher Ulrich PSD loading code released
+   on public domain. See: http://tulrich.com/geekstuff/
+*/
+
+/* this code supports:
+ * reading:
+ *     rle and raw psd files
+ * writing:
+ *     not supported
+ */
+
+#include "psd.h"
+
+#include <qimage.h>
+#include <qdatastream.h>
+
+#include <kdebug.h>
+
+typedef Q_UINT32 uint;
+typedef Q_UINT16 ushort;
+typedef Q_UINT8 uchar;
+
+namespace {	// Private.
+
+	enum ColorMode {
+		CM_BITMAP = 0,
+		CM_GRAYSCALE = 1,
+		CM_INDEXED = 2,
+		CM_RGB = 3,
+		CM_CMYK = 4,
+		CM_MULTICHANNEL = 7,
+		CM_DUOTONE = 8,
+		CM_LABCOLOR = 9
+	};
+
+	struct PSDHeader {
+		uint signature;
+		ushort version;
+		uchar reserved[6];
+		ushort channel_count;
+		uint height;
+		uint width;
+		ushort depth;
+		ushort color_mode;
+	};
+	
+	static QDataStream & operator>> ( QDataStream & s, PSDHeader & header )
+	{
+		s >> header.signature;
+		s >> header.version;
+		for( int i = 0; i < 6; i++ ) {
+			s >> header.reserved[i];
+		}
+		s >> header.channel_count;
+		s >> header.height;
+		s >> header.width;
+		s >> header.depth;
+		s >> header.color_mode;
+		return s;
+	}
+        static bool seekBy(QDataStream& s, unsigned int bytes)
+        {
+                char buf[4096];
+                while (bytes) {
+                        unsigned int num= QMIN(bytes,sizeof(buf));
+                        unsigned int l = num;
+                        s.readRawBytes(buf, l);
+                        if(l != num)
+                          return false;
+                        bytes -= num;
+                }
+                return true;
+        }
+
+	// Check that the header is a valid PSD.
+	static bool IsValid( const PSDHeader & header )
+	{
+		if( header.signature != 0x38425053 ) {	// '8BPS'
+			return false;
+		}
+		return true;
+	}
+
+	// Check that the header is supported.
+	static bool IsSupported( const PSDHeader & header )
+	{
+		if( header.version != 1 ) {
+			return false;
+		}
+		if( header.channel_count > 16 ) {
+			return false;
+		}
+		if( header.depth != 8 ) {
+			return false;
+		}
+		if( header.color_mode != CM_RGB ) {
+			return false;
+		}
+		return true;
+	}
+
+	// Load the PSD image.
+	static bool LoadPSD( QDataStream & s, const PSDHeader & header, QImage & img )
+	{
+		// Create dst image.
+		if( !img.create( header.width, header.height, 32 )) {
+			return false;
+		}
+	
+		uint tmp;
+
+		// Skip mode data.
+		s >> tmp;
+		s.device()->at( s.device()->at() + tmp );
+
+		// Skip image resources.
+		s >> tmp;
+		s.device()->at( s.device()->at() + tmp );
+
+		// Skip the reserved data.
+		s >> tmp;
+		s.device()->at( s.device()->at() + tmp );
+		
+		// Find out if the data is compressed.
+		// Known values:
+		//   0: no compression
+		//   1: RLE compressed
+		ushort compression;
+		s >> compression;
+		
+		if( compression > 1 ) {
+			// Unknown compression type.
+			return false;
+		}
+
+		uint channel_num = header.channel_count;
+		
+		// Clear the image.
+		if( channel_num < 4 ) {
+			img.fill(qRgba(0, 0, 0, 0xFF));
+		}
+		else {
+			// Enable alpha.		
+			img.setAlphaBuffer( true );
+			
+			// Ignore the other channels.
+			channel_num = 4;			
+		}
+		
+		const uint pixel_count = header.height * header.width;
+		
+		static const uint components[4] = {2, 1, 0, 3}; // @@ Is this endian dependant?
+		
+		if( compression ) {
+		
+			// Skip row lengths.
+                        if(!seekBy(s, header.height*header.channel_count*sizeof(ushort)))
+                                return false;
+
+			// Read RLE data.						
+			for(uint channel = 0; channel < channel_num; channel++) {
+			
+				uchar * ptr = img.bits() + components[channel];
+				
+				uint count = 0;
+				while( count < pixel_count ) {
+					uchar c;
+                                        if(s.atEnd())
+                                                return false;
+					s >> c;
+					uint len = c;
+					
+					if( len < 128 ) {
+						// Copy next len+1 bytes literally.
+						len++;
+						count += len;
+                                                if ( count > pixel_count )
+                                                        return false;
+
+						while( len != 0 ) {
+							s >> *ptr;
+							ptr += 4;
+							len--;
+						}
+					} 
+					else if( len > 128 ) {
+						// Next -len+1 bytes in the dest are replicated from next source byte.
+						// (Interpret len as a negative 8-bit int.)
+						len ^= 0xFF;
+						len += 2;
+						count += len;
+                                                if(s.atEnd() || count > pixel_count)
+                                                        return false;
+						uchar val;
+						s >> val;
+						while( len != 0 ) {
+							*ptr = val;
+							ptr += 4;
+							len--;
+						}
+					}
+					else if( len == 128 ) {
+						// No-op.
+					}
+				}
+			}
+		}
+		else {
+			// We're at the raw image data.  It's each channel in order (Red, Green, Blue, Alpha, ...)
+			// where each channel consists of an 8-bit value for each pixel in the image.
+
+			// Read the data by channel.
+			for(uint channel = 0; channel < channel_num; channel++) {
+
+				uchar * ptr = img.bits() + components[channel];
+			
+				// Read the data.
+				uint count = pixel_count;
+				while( count != 0 ) {
+					s >> *ptr;
+					ptr += 4;
+					count--;
+				}
+			}
+		}
+
+		return true;
+	}
+
+} // Private
+
+
+void kimgio_psd_read( QImageIO *io )
+{
+	QDataStream s( io->ioDevice() );
+	s.setByteOrder( QDataStream::BigEndian );
+
+	PSDHeader header;
+	s >> header;
+
+	// Check image file format.
+	if( s.atEnd() || !IsValid( header ) ) {
+		kdDebug(399) << "This PSD file is not valid." << endl;
+		io->setImage( 0 );
+		io->setStatus( -1 );
+		return;
+	}
+
+	// Check if it's a supported format.
+	if( !IsSupported( header ) ) {
+		kdDebug(399) << "This PSD file is not supported." << endl;
+		io->setImage( 0 );
+		io->setStatus( -1 );
+		return;
+	}
+
+	QImage img;
+	if( !LoadPSD(s, header, img) ) {
+		kdDebug(399) << "Error loading PSD file." << endl;
+		io->setImage( 0 );
+		io->setStatus( -1 );
+		return;
+	}
+
+    io->setImage( img );
+    io->setStatus( 0 );
+}
+
+
+void kimgio_psd_write( QImageIO * )
+{
+	// TODO Stub!
+}
+