Added libksquirrel for KDE3

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

1 files changed, 635 insertions, 0 deletions

diff --git a/kernel/kls_psp/fmt_codec_psp.cpp b/kernel/kls_psp/fmt_codec_psp.cpp
new file mode 100644
index 0000000..e77caa4
--- /dev/null
+++ b/kernel/kls_psp/fmt_codec_psp.cpp
@@ -0,0 +1,635 @@
+/*  This file is part of ksquirrel-libs (http://ksquirrel.sf.net)
+
+    Copyright (c) 2005 Dmitry Baryshev <ksquirrel@tut.by>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation;
+    either version 2 of the License, or (at your option) any later
+    version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include <iostream>
+#include <cstdlib>
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+#include <stdlib.h>
+
+#include "ksquirrel-libs/fmt_types.h"
+#include "ksquirrel-libs/fileio.h"
+#include "ksquirrel-libs/fmt_utils.h"
+
+#include "fmt_codec_psp_defs.h"
+#include "fmt_codec_psp.h"
+
+#include "ksquirrel-libs/error.h"
+
+#include "../xpm/codec_psp.xpm"
+
+fmt_codec::fmt_codec() : fmt_codec_base()
+{}
+
+fmt_codec::~fmt_codec()
+{}
+
+void fmt_codec::options(codec_options *o)
+{
+    o->version = "0.1.0";
+    o->name = "PaintShop Pro";
+    o->filter = "*.psp ";
+    o->config = "";
+    o->mime = "";
+    o->mimetype = "image/x-psp";
+    o->pixmap = codec_psp;
+    o->readable = true;
+    o->canbemultiple = false;
+    o->writestatic = false;
+    o->writeanimated = false;
+    o->needtempfile = false;
+}
+
+/************** Utility functions from DevIL *********************/
+
+//-----------------------------------------------------------------------------
+//
+// ImageLib Sources
+// Copyright (C) 2000-2002 by Denton Woods
+// Last modified: 05/04/2002 <--Y2K Compliant! =]
+//
+// Filename: src-IL/src/il_psp.c
+//
+// Description: Reads a Paint Shop Pro file.
+//
+//-----------------------------------------------------------------------------
+
+
+bool fmt_codec::iGetPspHead()
+{
+    if(!frs.readK(Header.FileSig, 32))
+        return false;
+
+    if(!frs.readK(&Header.MajorVersion, sizeof(Header.MajorVersion)))
+        return false;
+
+    if(!frs.readK(&Header.MinorVersion, sizeof(Header.MinorVersion)))
+        return false;
+
+        return true;
+}
+
+bool fmt_codec::iCheckPsp()
+{
+    if (strcmp(Header.FileSig, "Paint Shop Pro Image File\n\x1a")) // "i"
+            return false;
+    if (Header.MajorVersion < 3 || Header.MajorVersion > 5)
+            return false;
+    if (Header.MinorVersion != 0)
+            return false;
+
+    return true;
+}
+
+bool fmt_codec::ReadGenAttributes()
+{
+        BLOCKHEAD               AttHead;
+        ILint                   Padding;
+        ILuint                  ChunkLen;
+
+        if(!frs.readK(&AttHead, sizeof(AttHead)))
+            return false;
+
+        if (AttHead.HeadID[0] != 0x7E || AttHead.HeadID[1] != 0x42 || AttHead.HeadID[2] != 0x4B || AttHead.HeadID[3] != 0x00)
+                return false;
+
+        if (AttHead.BlockID != PSP_IMAGE_BLOCK)
+                return false;
+
+        if(!frs.readK(&ChunkLen, sizeof(ChunkLen)))
+            return false;
+
+        if (Header.MajorVersion != 3)
+                ChunkLen -= 4;
+
+        if (!frs.readK(&AttChunk, std::min(sizeof(AttChunk), size_t(ChunkLen))))
+                return false;
+
+        // Can have new entries in newer versions of the spec (4.0).
+        Padding = (ChunkLen) - sizeof(AttChunk);
+
+        if (Padding > 0)
+                frs.seekg(Padding, ios::cur);
+
+        // @TODO:  Anything but 24 not supported yet...
+        if (AttChunk.BitDepth != 24 && AttChunk.BitDepth != 8)
+                return false;
+
+        // @TODO;  Add support for compression...
+        if (AttChunk.Compression != PSP_COMP_NONE && AttChunk.Compression != PSP_COMP_RLE)
+                return false;
+
+        // @TODO: Check more things in the general attributes chunk here.
+        return true;
+}
+
+bool fmt_codec::ParseChunks()
+{
+        BLOCKHEAD       Block;
+        size_t          Pos;
+
+        do {
+                if (!frs.readK(&Block, sizeof(Block)))
+                    return true;
+
+                if (Header.MajorVersion == 3)
+                    frs.readK(&Block.BlockLen, sizeof(Block.BlockLen));
+
+                if (Block.HeadID[0] != 0x7E || Block.HeadID[1] != 0x42 || Block.HeadID[2] != 0x4B || Block.HeadID[3] != 0x00)
+                    return true;
+
+                Pos = frs.tellg();
+
+                switch (Block.BlockID)
+                {
+                        case PSP_LAYER_START_BLOCK:
+                                if (!ReadLayerBlock())
+                                        return false;
+                                break;
+
+                        case PSP_ALPHA_BANK_BLOCK:
+                                if (!ReadAlphaBlock())
+                                        return false;
+                                break;
+
+                        case PSP_COLOR_BLOCK:
+                                if (!ReadPalette())
+                                        return false;
+                                break;
+                }
+
+                // Skip to next block just in case we didn't read the entire block.
+                frs.seekg(Pos + Block.BlockLen, ios::beg);
+
+        }
+        while (1);
+
+        return true;
+}
+
+bool fmt_codec::ReadLayerBlock()
+{
+        BLOCKHEAD               Block;
+        LAYERINFO_CHUNK         LayerInfo;
+        LAYERBITMAP_CHUNK       Bitmap;
+        ILuint                  ChunkSize, Padding, i;
+        ILushort                NumChars;
+
+        // Layer sub-block header
+        if (!frs.readK(&Block, sizeof(Block)))
+                return false;
+
+        if(Header.MajorVersion == 3)
+            frs.readK(&Block.BlockLen, sizeof(Block.BlockLen));
+
+        if (Block.HeadID[0] != 0x7E || Block.HeadID[1] != 0x42 || Block.HeadID[2] != 0x4B || Block.HeadID[3] != 0x00)
+            return false;
+
+        if (Block.BlockID != PSP_LAYER_BLOCK)
+            return false;
+
+        if (Header.MajorVersion == 3)
+        {
+                frs.seekg(256, ios::cur);  // We don't care about the name of the layer.
+                frs.readK(&LayerInfo, sizeof(LayerInfo));
+
+                if(!frs.readK(&Bitmap, sizeof(Bitmap)))
+                    return false;
+        }
+        else
+        {  // Header.MajorVersion >= 4
+                frs.readK(&ChunkSize, sizeof(ChunkSize));
+                frs.readK(&NumChars, sizeof(NumChars));
+                frs.seekg(NumChars, ios::cur);  // We don't care about the layer's name.
+
+                ChunkSize -= (2 + 4 + NumChars);
+
+                if (!frs.readK(&LayerInfo, std::min(sizeof(LayerInfo), size_t(ChunkSize))))
+                        return false;
+
+                // Can have new entries in newer versions of the spec (5.0).
+                Padding = (ChunkSize) - sizeof(LayerInfo);
+
+                if (Padding > 0)
+                        frs.seekg(Padding, ios::cur);
+
+                frs.readK(&ChunkSize, sizeof(ChunkSize));
+
+                if (!frs.readK(&Bitmap, sizeof(Bitmap)))
+                        return false;
+
+                Padding = (ChunkSize - 4) - sizeof(Bitmap);
+
+                if (Padding > 0)
+                        frs.seekg(Padding, ios::cur);
+        }
+
+        Channels = new ILubyte* [Bitmap.NumChannels];
+
+        if (!Channels)
+            return false;
+
+        NumChannels = Bitmap.NumChannels;
+
+        for (i = 0; i < NumChannels; i++)
+            Channels[i] = 0;
+
+        for (i = 0; i < NumChannels; i++)
+        {
+                Channels[i] = GetChannel();
+
+                if(!Channels[i])
+                        return false;
+        }
+
+        return true;
+}
+
+bool fmt_codec::ReadAlphaBlock()
+{
+        BLOCKHEAD               Block;
+        ALPHAINFO_CHUNK AlphaInfo;
+        ALPHA_CHUNK             AlphaChunk;
+        ILushort                NumAlpha, StringSize;
+        ILuint                  ChunkSize, Padding;
+
+        if (Header.MajorVersion == 3) {
+                frs.readK(&NumAlpha, sizeof(NumAlpha));
+        }
+        else {
+                frs.readK(&ChunkSize, sizeof(ChunkSize));
+                frs.readK(&NumAlpha, sizeof(NumAlpha));
+
+                Padding = (ChunkSize - 4 - 2);
+
+                if (Padding > 0)
+                        frs.seekg(Padding, ios::cur);
+        }
+
+        // Alpha channel header
+        if (!frs.readK(&Block, sizeof(Block)))
+                return false;
+
+        if (Header.MajorVersion == 3)
+                frs.readK(&Block.BlockLen, sizeof(Block.BlockLen));
+
+        if (Block.HeadID[0] != 0x7E || Block.HeadID[1] != 0x42 ||
+                Block.HeadID[2] != 0x4B || Block.HeadID[3] != 0x00) {
+                        return false;
+        }
+        if (Block.BlockID != PSP_ALPHA_CHANNEL_BLOCK)
+                return false;
+
+        if (Header.MajorVersion >= 4)
+        {
+                frs.readK(&ChunkSize, sizeof(ChunkSize));
+                frs.readK(&StringSize, sizeof(StringSize));
+
+                frs.seekg(StringSize, ios::cur);
+
+                if (!frs.readK(&AlphaInfo, sizeof(AlphaInfo)))
+                        return false;
+
+                Padding = (ChunkSize - 4 - 2 - StringSize - sizeof(AlphaInfo));
+
+                if (Padding > 0)
+                        frs.seekg(Padding, ios::cur);
+
+                frs.readK(&ChunkSize, sizeof(ChunkSize));
+
+                if (!frs.readK(&AlphaChunk, sizeof(AlphaChunk)))
+                        return false;
+
+                Padding = (ChunkSize - 4 - sizeof(AlphaChunk));
+
+                if (Padding > 0)
+                        frs.seekg(Padding, ios::cur);
+        }
+        else {
+                frs.seekg(256, ios::cur);
+                frs.readK(&AlphaInfo, sizeof(AlphaInfo));
+
+                if(!frs.readK(&AlphaChunk, sizeof(AlphaChunk)))
+                        return false;
+        }
+
+        Alpha = GetChannel();
+
+        if (!Alpha)
+                return false;
+
+        return true;
+}
+
+ILubyte *fmt_codec::GetChannel()
+{
+        BLOCKHEAD       Block;
+        CHANNEL_CHUNK   Channel;
+        ILubyte         *CompData = 0, *Data = 0;
+        ILuint          ChunkSize, Padding;
+
+        if (!frs.readK(&Block, sizeof(Block)))
+                return 0;
+
+        if (Header.MajorVersion == 3)
+            frs.readK(&Block.BlockLen, sizeof(Block.BlockLen));
+
+        if (Block.HeadID[0] != 0x7E || Block.HeadID[1] != 0x42 ||  Block.HeadID[2] != 0x4B || Block.HeadID[3] != 0x00)
+            return 0;
+
+        if (Block.BlockID != PSP_CHANNEL_BLOCK)
+            return 0;
+
+        if (Header.MajorVersion >= 4)
+        {
+                frs.readK(&ChunkSize, sizeof(ChunkSize));
+
+                if (!frs.readK(&Channel, sizeof(Channel)))
+                        return 0;
+
+                Padding = (ChunkSize - 4) - sizeof(Channel);
+
+                if (Padding > 0)
+                        frs.seekg(Padding, ios::cur);
+        }
+        else
+        {
+                if (!frs.readK(&Channel, sizeof(Channel)))
+                        return 0;
+        }
+
+        CompData = new ILubyte [Channel.CompLen];
+
+        if (!CompData)
+            return 0;
+
+        if (!frs.readK(CompData, Channel.CompLen))
+        {
+                delete CompData;
+                return 0;
+        }
+
+        if(AttChunk.Compression != PSP_COMP_NONE)
+        {
+            Data = new ILubyte [AttChunk.Width * AttChunk.Height];
+
+            if (!Data)
+            {
+                    delete CompData;
+                    return 0;
+            }
+        }
+
+        switch (AttChunk.Compression)
+        {
+                case PSP_COMP_NONE:
+                    return CompData;
+
+                case PSP_COMP_RLE:
+                    if (!UncompRLE(CompData, Data, Channel.CompLen))
+                    {
+                        delete Data;
+                        delete CompData;
+                        return 0;
+                    }
+                break;
+
+                default:
+                    delete Data;
+                    delete CompData;
+                return 0;
+        }
+
+        delete CompData;
+
+        return Data;
+}
+
+bool fmt_codec::UncompRLE(ILubyte *CompData, ILubyte *Data, ILuint CompLen)
+{
+        ILubyte Run, Colour;
+        ILint   i, Count;
+
+        for (i = 0, Count = 0; i < (ILint)CompLen; ) {
+                Run = *CompData++;
+                i++;
+                if (Run > 128) {
+                        Run -= 128;
+                        Colour = *CompData++;
+                        i++;
+                        memset(Data, Colour, Run);
+                }
+                else {
+                        memcpy(Data, CompData, Run);
+                        CompData += Run;
+                        i += Run;
+                }
+                Data += Run;
+                Count += Run;
+        }
+
+        return true;
+}
+
+bool fmt_codec::ReadPalette()
+{
+        ILuint ChunkSize, PalCount, Padding;
+        RGBA rgba;
+
+        if (Header.MajorVersion >= 4)
+        {
+            frs.readK(&ChunkSize, sizeof(ChunkSize));
+            frs.readK(&PalCount, sizeof(PalCount));
+
+            Padding = (ChunkSize - 4 - 4);
+
+            if (Padding > 0)
+                frs.seekg(Padding, ios::cur);
+        }
+        else
+            frs.readK(&PalCount, sizeof(PalCount));
+
+        pal = new RGBA [PalCount];
+
+        if(!pal)
+            return false;
+
+        RGBA *ppal = pal;
+
+        for(u32 i = 0;i < PalCount;i++)
+        {
+            if(!frs.readK(&rgba, sizeof(RGBA)))
+                return false;
+
+            ppal->r = rgba.b;
+            ppal->g = rgba.g;
+            ppal->b = rgba.r;
+            ppal->a = rgba.a;
+
+            ppal++;
+        }
+
+        return true;
+}
+
+/******************** ksquirrel-libs stuff ****************************/
+
+s32 fmt_codec::read_init(const std::string &file)
+{
+    Channels = 0;
+    Alpha = 0;
+    pal = 0;
+
+    frs.open(file.c_str(), ios::binary | ios::in);
+
+    if(!frs.good())
+        return SQE_R_NOFILE;
+
+    currentImage = -1;
+    read_error = false;
+    finfo.animated = false;
+
+    if(!iGetPspHead())
+        return SQE_R_BADFILE;
+
+    if(!iCheckPsp())
+        return SQE_R_BADFILE;
+
+    return SQE_OK;
+}
+
+s32 fmt_codec::read_next()
+{
+    currentImage++;
+
+    if(currentImage)
+        return SQE_NOTOK;
+
+    if(!ReadGenAttributes())
+        return SQE_R_BADFILE;
+
+    if(!ParseChunks())
+        return SQE_R_BADFILE;
+
+//    if(!AssembleImage())
+//        return SQE_R_BADFILE;
+
+    fmt_image image;
+
+    image.w = AttChunk.Width;
+    image.h = AttChunk.Height;
+    image.compression = (AttChunk.Compression == PSP_COMP_RLE ? "RLE" : "-");
+    image.bpp = (NumChannels == 1 ? 8 : ((Alpha || NumChannels == 4) ? 32 : 24));
+    image.colorspace = fmt_utils::colorSpaceByBpp(image.bpp);
+
+    finfo.image.push_back(image);
+
+    return SQE_OK;
+}
+
+s32 fmt_codec::read_next_pass()
+{
+    line = -1;
+
+    return SQE_OK;
+}
+
+s32 fmt_codec::read_scanline(RGBA *scan)
+{
+    line++;
+
+    fmt_image *im = image(currentImage);
+
+    u32 i, j;
+    u32 ifrom = line * im->w;
+    u32 ito = ifrom + im->w;
+
+    if (NumChannels == 1)
+    {
+        memset(scan, 0, im->w * sizeof(RGBA));
+
+        for (i = ifrom, j = 0; i < ito; i++, j++)
+        {
+            scan[j] = pal[Channels[0][i]];
+            scan[j].a = 255;
+        }
+    }
+    else
+    {
+        if (Alpha)
+        {
+            memset(scan, 0, im->w * sizeof(RGBA));
+            u8 *data = (u8 *)scan;
+
+            for (i = ifrom, j = 0; i < ito; i++, j += 4)
+            {
+                data[j  ] = Channels[0][i];
+                data[j+1] = Channels[1][i];
+                data[j+2] = Channels[2][i];
+                data[j+3] = Alpha[i];
+            }
+        }
+        // 3 channels, or 4 without alpha
+        else if (NumChannels == 3 || NumChannels == 4)
+        {
+            memset(scan, 0, im->w * sizeof(RGBA));
+            u8 *data = (u8 *)scan;
+
+            for (i = ifrom, j = 0; i < ito; i++, j += 4)
+            {
+                data[j  ] = Channels[0][i];
+                data[j+1] = Channels[1][i];
+                data[j+2] = Channels[2][i];
+                data[j+3] = 255;
+            }
+        }
+        else
+            return SQE_R_BADFILE;
+    }
+
+    return SQE_OK;
+}
+
+void fmt_codec::read_close()
+{
+    frs.close();
+
+    if(Channels)
+    {
+        for (u32 i = 0; i < NumChannels; i++)
+            delete Channels[i];
+
+        delete Channels;
+    }
+
+    delete Alpha;
+    delete pal;
+
+    Channels = 0;
+    Alpha = 0;
+    pal = 0;
+
+    finfo.meta.clear();
+    finfo.image.clear();
+}
+
+#include "fmt_codec_cd_func.h"