xcf.cpp

/*
 * qxcfi.cpp: A Qt 3 plug-in for reading GIMP XCF image files
 * Copyright (C) 2001 lignum Computing, Inc. <allen@lignumcomputing.com>
 * Copyright (C) 2004 Melchior FRANZ <mfranz@kde.org>
 *
 * This plug-in is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */
 
#include <stdlib.h>
#include <tqimage.h>
#include <tqiodevice.h>
#include <tqvaluestack.h>
#include <tqvaluevector.h>
 
#include <kdebug.h>
#include "xcf.h"
 
 
 
 
TDE_EXPORT void kimgio_xcf_read(TQImageIO *io)
{
    XCFImageFormat xcfif;
    xcfif.readXCF(io);
}
 
 
TDE_EXPORT void kimgio_xcf_write(TQImageIO *io)
{
    kdDebug(399) << "XCF: write support not implemented" << endl;
    io->setStatus(-1);
}
 
 
 
 
int XCFImageFormat::random_table[RANDOM_TABLE_SIZE];
 
//int XCFImageFormat::add_lut[256][256];
 
 
const XCFImageFormat::LayerModes XCFImageFormat::layer_modes[] = {
    {true},     // NORMAL_MODE
    {true},     // DISSOLVE_MODE
    {true},     // BEHIND_MODE
    {false},    // MULTIPLY_MODE
    {false},    // SCREEN_MODE
    {false},    // OVERLAY_MODE
    {false},    // DIFFERENCE_MODE
    {false},    // ADDITION_MODE
    {false},    // SUBTRACT_MODE
    {false},    // DARKEN_ONLY_MODE
    {false},    // LIGHTEN_ONLY_MODE
    {false},    // HUE_MODE
    {false},    // SATURATION_MODE
    {false},    // COLOR_MODE
    {false},    // VALUE_MODE
    {false},    // DIVIDE_MODE
    {true},     // ERASE_MODE
    {true},     // REPLACE_MODE
    {true},     // ANTI_ERASE_MODE
};
 
 
inline TQRgb tqRgba ( TQRgb rgb, int a )
{
    return ((a & 0xff) << 24 | (rgb & TQT_RGB_MASK));
}
 
 
XCFImageFormat::XCFImageFormat()
{
    // From GIMP "paint_funcs.c" v1.2
    srand(RANDOM_SEED);
 
    for (int i = 0; i < RANDOM_TABLE_SIZE; i++)
        random_table[i] = rand();
 
    for (int i = 0; i < RANDOM_TABLE_SIZE; i++) {
        int tmp;
        int swap = i + rand() % (RANDOM_TABLE_SIZE - i);
        tmp = random_table[i];
        random_table[i] = random_table[swap];
        random_table[swap] = tmp;
    }
 
//  for (int j = 0; j < 256; j++) {
//      for (int k = 0; k < 256; k++) {
//          int tmp_sum = j + k;
//          if (tmp_sum > 255)
//              tmp_sum = 255;
//          add_lut[j][k] = tmp_sum;
//      }
//  }
}
 
inline
int XCFImageFormat::add_lut( int a, int b ) {
    return TQMIN( a + b, 255 );
}
 
void XCFImageFormat::readXCF(TQImageIO *io)
{
    XCFImage xcf_image;
    TQDataStream xcf_io(io->ioDevice());
 
    char tag[14];
    xcf_io.readRawBytes(tag, sizeof(tag));
 
    if (xcf_io.device()->status() != IO_Ok) {
        kdDebug(399) << "XCF: read failure on header tag" << endl;
        return;
    }
 
    xcf_io >> xcf_image.width >> xcf_image.height >> xcf_image.type;
 
    if (xcf_io.device()->status() != IO_Ok) {
        kdDebug(399) << "XCF: read failure on image info" << endl;
        return;
    }
 
kdDebug() << tag << " " << xcf_image.width << " " << xcf_image.height << " " <<  xcf_image.type << endl;
    if (!loadImageProperties(xcf_io, xcf_image))
        return;
 
    // The layers appear to be stored in top-to-bottom order. This is
    // the reverse of how a merged image must be computed. So, the layer
    // offsets are pushed onto a LIFO stack (thus, we don't have to load
    // all the data of all layers before beginning to construct the
    // merged image).
 
    TQValueStack<TQ_INT32> layer_offsets;
 
    while (true) {
        TQ_INT32 layer_offset;
 
        xcf_io >> layer_offset;
 
        if (xcf_io.device()->status() != IO_Ok) {
            kdDebug(399) << "XCF: read failure on layer offsets" << endl;
            return;
        }
 
        if (layer_offset == 0)
            break;
 
        layer_offsets.push(layer_offset);
    }
 
    xcf_image.num_layers = layer_offsets.size();
 
    if (layer_offsets.size() == 0) {
        kdDebug(399) << "XCF: no layers!" << endl;
        return;
    }
 
    // Load each layer and add it to the image
    while (!layer_offsets.isEmpty()) {
        TQ_INT32 layer_offset = layer_offsets.pop();
 
        xcf_io.device()->at(layer_offset);
 
        if (!loadLayer(xcf_io, xcf_image))
            return;
    }
 
    if (!xcf_image.initialized) {
        kdDebug(399) << "XCF: no visible layers!" << endl;
        return;
    }
 
    io->setImage(xcf_image.image);
    io->setStatus(0);
}
 
 
bool XCFImageFormat::loadImageProperties(TQDataStream& xcf_io, XCFImage& xcf_image)
{
    while (true) {
        PropType type;
        TQByteArray bytes;
 
        if (!loadProperty(xcf_io, type, bytes)) {
            kdDebug(399) << "XCF: error loading global image properties" << endl;
            return false;
        }
 
        TQDataStream property(bytes, IO_ReadOnly);
 
        switch (type) {
            case PROP_END:
                return true;
 
            case PROP_COMPRESSION:
                property >> xcf_image.compression;
                break;
 
            case PROP_RESOLUTION:
                property >> xcf_image.x_resolution >> xcf_image.y_resolution;
                break;
 
            case PROP_TATTOO:
                property >> xcf_image.tattoo;
                break;
 
            case PROP_PARASITES:
                while (!property.atEnd()) {
                    char* tag;
                    TQ_UINT32 size;
 
                    property.readBytes(tag, size);
 
                    TQ_UINT32 flags;
                    char* data=0;
                    property >> flags >> data;
 
                    if (tag && strncmp(tag, "gimp-comment", strlen("gimp-comment")) == 0)
                        xcf_image.image.setText("Comment", 0, data);
 
                    delete[] tag;
                    delete[] data;
                }
                break;
 
                case PROP_UNIT:
                    property >> xcf_image.unit;
                    break;
 
                case PROP_PATHS:    // This property is ignored.
                    break;
 
                case PROP_USER_UNIT:    // This property is ignored.
                    break;
 
                case PROP_COLORMAP:
                    property >> xcf_image.num_colors;
                                        if(xcf_image.num_colors < 0 || xcf_image.num_colors > 65535)
                                            return false;
 
                    xcf_image.palette.reserve(xcf_image.num_colors);
 
                    for (int i = 0; i < xcf_image.num_colors; i++) {
                        uchar r, g, b;
                        property >> r >> g >> b;
                        xcf_image.palette.push_back( tqRgb(r,g,b) );
                    }
                    break;
 
                default:
                    kdDebug(399) << "XCF: unimplemented image property" << type
                            << ", size " << bytes.size() << endl;
        }
    }
}
 
 
bool XCFImageFormat::loadProperty(TQDataStream& xcf_io, PropType& type, TQByteArray& bytes)
{
    TQ_UINT32 foo;
    xcf_io >> foo;
    type=PropType(foo); // TODO urks
 
    if (xcf_io.device()->status() != IO_Ok) {
        kdDebug(399) << "XCF: read failure on property type" << type << endl;
        return false;
    }
 
    char* data;
    TQ_UINT32 size;
 
    // The colormap property size is not the correct number of bytes:
    // The GIMP source xcf.c has size = 4 + ncolors, but it should be
    // 4 + 3 * ncolors
 
    if (type == PROP_COLORMAP) {
        xcf_io >> size;
 
        if (xcf_io.device()->status() != IO_Ok) {
            kdDebug(399) << "XCF: read failure on property " << type << " size" << endl;
            return false;
        }
 
                if(size > 65535 || size < 4)
                    return false;
 
        size = 3 * (size - 4) + 4;
        data = new char[size];
 
        xcf_io.readRawBytes(data, size);
    } else if (type == PROP_USER_UNIT) {
        // The USER UNIT property size is not correct. I'm not sure why, though.
        float factor;
        TQ_INT32 digits;
        char* unit_strings;
 
        xcf_io >> size >> factor >> digits;
 
        if (xcf_io.device()->status() != IO_Ok) {
            kdDebug(399) << "XCF: read failure on property " << type << endl;
            return false;
        }
 
        for (int i = 0; i < 5; i++) {
            xcf_io >> unit_strings;
 
            if (xcf_io.device()->status() != IO_Ok) {
                kdDebug(399) << "XCF: read failure on property " << type << endl;
                return false;
            }
 
            delete[] unit_strings;
        }
 
        size = 0;
    } else {
                xcf_io >> size;
                if(size >256000)
                    return false;
                data = new char[size];
        xcf_io.readRawBytes(data, size);
        }
 
    if (xcf_io.device()->status() != IO_Ok) {
        kdDebug(399) << "XCF: read failure on property " << type << " data, size " << size << endl;
        return false;
    }
 
    if (size != 0 && data) {
                bytes.assign(data,size);
    }
 
    return true;
}
 
 
bool XCFImageFormat::loadLayer(TQDataStream& xcf_io, XCFImage& xcf_image)
{
    Layer& layer(xcf_image.layer);
    delete[] layer.name;
 
    xcf_io >> layer.width >> layer.height >> layer.type >> layer.name;
 
    if (xcf_io.device()->status() != IO_Ok) {
        kdDebug(399) << "XCF: read failure on layer" << endl;
        return false;
    }
 
    if (!loadLayerProperties(xcf_io, layer))
        return false;
#if 0
  cout << "layer: \"" << layer.name << "\", size: " << layer.width << " x "
       << layer.height << ", type: " << layer.type << ", mode: " << layer.mode
       << ", opacity: " << layer.opacity << ", visible: " << layer.visible
       << ", offset: " << layer.x_offset << ", " << layer.y_offset << endl;
#endif
  // Skip reading the rest of it if it is not visible. Typically, when
  // you export an image from the The GIMP it flattens (or merges) only
  // the visible layers into the output image.
 
    if (layer.visible == 0)
        return true;
 
    // If there are any more layers, merge them into the final TQImage.
 
    xcf_io >> layer.hierarchy_offset >> layer.mask_offset;
    if (xcf_io.device()->status() != IO_Ok) {
        kdDebug(399) << "XCF: read failure on layer image offsets" << endl;
        return false;
    }
 
    // Allocate the individual tile QImages based on the size and type
    // of this layer.
 
    if( !composeTiles(xcf_image))
        return false;
    xcf_io.device()->at(layer.hierarchy_offset);
 
    // As tiles are loaded, they are copied into the layers tiles by
    // this routine. (loadMask(), below, uses a slightly different
    // version of assignBytes().)
 
    layer.assignBytes = assignImageBytes;
 
    if (!loadHierarchy(xcf_io, layer))
        return false;
 
    if (layer.mask_offset != 0) {
        xcf_io.device()->at(layer.mask_offset);
 
        if (!loadMask(xcf_io, layer))
            return false;
    }
 
    // Now we should have enough information to initialize the final
    // TQImage. The first visible layer determines the attributes
    // of the TQImage.
 
    if (!xcf_image.initialized) {
        if( !initializeImage(xcf_image))
            return false;
        copyLayerToImage(xcf_image);
        xcf_image.initialized = true;
    } else
        mergeLayerIntoImage(xcf_image);
 
    return true;
}
 
 
bool XCFImageFormat::loadLayerProperties(TQDataStream& xcf_io, Layer& layer)
{
    while (true) {
        PropType type;
        TQByteArray bytes;
 
        if (!loadProperty(xcf_io, type, bytes)) {
            kdDebug(399) << "XCF: error loading layer properties" << endl;
            return false;
        }
 
        TQDataStream property(bytes, IO_ReadOnly);
 
        switch (type) {
            case PROP_END:
                return true;
 
            case PROP_ACTIVE_LAYER:
                layer.active = true;
                break;
 
            case PROP_OPACITY:
                property >> layer.opacity;
                break;
 
            case PROP_VISIBLE:
                property >> layer.visible;
                break;
 
            case PROP_LINKED:
                property >> layer.linked;
                break;
 
            case PROP_PRESERVE_TRANSPARENCY:
                property >> layer.preserve_transparency;
                break;
 
            case PROP_APPLY_MASK:
                property >> layer.apply_mask;
                break;
 
            case PROP_EDIT_MASK:
                property >> layer.edit_mask;
                break;
 
            case PROP_SHOW_MASK:
                property >> layer.show_mask;
                break;
 
            case PROP_OFFSETS:
                property >> layer.x_offset >> layer.y_offset;
                break;
 
            case PROP_MODE:
                property >> layer.mode;
                break;
 
            case PROP_TATTOO:
                property >> layer.tattoo;
                break;
 
            default:
                kdDebug(399) << "XCF: unimplemented layer property " << type
                        << ", size " << bytes.size() << endl;
        }
    }
}
 
 
bool XCFImageFormat::composeTiles(XCFImage& xcf_image)
{
    Layer& layer(xcf_image.layer);
 
    layer.nrows = (layer.height + TILE_HEIGHT - 1) / TILE_HEIGHT;
    layer.ncols = (layer.width + TILE_WIDTH - 1) / TILE_WIDTH;
 
    layer.image_tiles.resize(layer.nrows);
 
    if (layer.type == GRAYA_GIMAGE || layer.type == INDEXEDA_GIMAGE)
        layer.alpha_tiles.resize(layer.nrows);
 
    if (layer.mask_offset != 0)
        layer.mask_tiles.resize(layer.nrows);
 
    for (uint j = 0; j < layer.nrows; j++) {
        layer.image_tiles[j].resize(layer.ncols);
 
        if (layer.type == GRAYA_GIMAGE || layer.type == INDEXEDA_GIMAGE)
            layer.alpha_tiles[j].resize(layer.ncols);
 
        if (layer.mask_offset != 0)
            layer.mask_tiles[j].resize(layer.ncols);
    }
 
    for (uint j = 0; j < layer.nrows; j++) {
        for (uint i = 0; i < layer.ncols; i++) {
 
            uint tile_width = (i + 1) * TILE_WIDTH <= layer.width
                    ? TILE_WIDTH : layer.width - i * TILE_WIDTH;
 
            uint tile_height = (j + 1) * TILE_HEIGHT <= layer.height
                    ? TILE_HEIGHT : layer.height - j * TILE_HEIGHT;
 
            // Try to create the most appropriate TQImage (each GIMP layer
            // type is treated slightly differently)
 
            switch (layer.type) {
                case RGB_GIMAGE:
                    layer.image_tiles[j][i] = TQImage(tile_width, tile_height, 32, 0);
                    if( layer.image_tiles[j][i].isNull())
                        return false;
                    layer.image_tiles[j][i].setAlphaBuffer(false);
                    break;
 
                case RGBA_GIMAGE:
                    layer.image_tiles[j][i] = TQImage(tile_width, tile_height, 32, 0);
                    if( layer.image_tiles[j][i].isNull())
                        return false;
                    layer.image_tiles[j][i].setAlphaBuffer(true);
                    break;
 
                case GRAY_GIMAGE:
                    layer.image_tiles[j][i] = TQImage(tile_width, tile_height, 8, 256);
                    if( layer.image_tiles[j][i].isNull())
                        return false;
                    setGrayPalette(layer.image_tiles[j][i]);
                    break;
 
                case GRAYA_GIMAGE:
                    layer.image_tiles[j][i] = TQImage(tile_width, tile_height, 8, 256);
                    if( layer.image_tiles[j][i].isNull())
                        return false;
                    setGrayPalette(layer.image_tiles[j][i]);
 
                    layer.alpha_tiles[j][i] = TQImage( tile_width, tile_height, 8, 256);
                    if( layer.alpha_tiles[j][i].isNull())
                        return false;
                    setGrayPalette(layer.alpha_tiles[j][i]);
                    break;
 
                case INDEXED_GIMAGE:
                    layer.image_tiles[j][i] = TQImage(tile_width, tile_height, 8,
                            xcf_image.num_colors);
                    if( layer.image_tiles[j][i].isNull())
                        return false;
                    setPalette(xcf_image, layer.image_tiles[j][i]);
                    break;
 
                case INDEXEDA_GIMAGE:
                    layer.image_tiles[j][i] = TQImage(tile_width, tile_height,8,
                            xcf_image.num_colors);
                    if( layer.image_tiles[j][i].isNull())
                        return false;
                    setPalette(xcf_image, layer.image_tiles[j][i]);
 
                    layer.alpha_tiles[j][i] = TQImage(tile_width, tile_height, 8, 256);
                    if( layer.alpha_tiles[j][i].isNull())
                        return false;
                    setGrayPalette(layer.alpha_tiles[j][i]);
            }
 
            if (layer.mask_offset != 0) {
                layer.mask_tiles[j][i] = TQImage(tile_width, tile_height, 8, 256);
                if( layer.mask_tiles[j][i].isNull())
                    return false;
                setGrayPalette(layer.mask_tiles[j][i]);
            }
        }
    }
    return true;
}
 
 
void XCFImageFormat::setGrayPalette(TQImage& image)
{
    for (int i = 0; i < 256; i++)
        image.setColor(i, tqRgb(i, i, i));
}
 
 
void XCFImageFormat::setPalette(XCFImage& xcf_image, TQImage& image)
{
    for (int i = 0; i < xcf_image.num_colors; i++)
        image.setColor(i, xcf_image.palette[i]);
}
 
 
void XCFImageFormat::assignImageBytes(Layer& layer, uint i, uint j)
{
    uchar* tile = layer.tile;
 
    switch (layer.type) {
        case RGB_GIMAGE:
            for (int l = 0; l < layer.image_tiles[j][i].height(); l++) {
                for (int k = 0; k < layer.image_tiles[j][i].width(); k++) {
                    layer.image_tiles[j][i].setPixel(k, l,
                            tqRgb(tile[0], tile[1], tile[2]));
                    tile += sizeof(TQRgb);
                }
            }
            break;
 
        case RGBA_GIMAGE:
            for ( int l = 0; l < layer.image_tiles[j][i].height(); l++ ) {
                for ( int k = 0; k < layer.image_tiles[j][i].width(); k++ ) {
                    layer.image_tiles[j][i].setPixel(k, l,
                            tqRgba(tile[0], tile[1], tile[2], tile[3]));
                    tile += sizeof(TQRgb);
                }
            }
            break;
 
        case GRAY_GIMAGE:
        case INDEXED_GIMAGE:
            for (int l = 0; l < layer.image_tiles[j][i].height(); l++) {
                for (int k = 0; k < layer.image_tiles[j][i].width(); k++) {
                    layer.image_tiles[j][i].setPixel(k, l, tile[0]);
                    tile += sizeof(TQRgb);
                }
            }
            break;
 
        case GRAYA_GIMAGE:
        case INDEXEDA_GIMAGE:
            for (int l = 0; l < layer.image_tiles[j][i].height(); l++) {
                for (int k = 0; k < layer.image_tiles[j][i].width(); k++) {
 
                // The "if" here should not be necessary, but apparently there
                // are some cases where the image can contain larger indices
                // than there are colors in the palette. (A bug in The GIMP?)
 
                    if (tile[0] < layer.image_tiles[j][i].numColors())
                        layer.image_tiles[j][i].setPixel(k, l, tile[0]);
 
                    layer.alpha_tiles[j][i].setPixel(k, l, tile[1]);
                    tile += sizeof(TQRgb);
                }
            }
            break;
    }
}
 
 
bool XCFImageFormat::loadHierarchy(TQDataStream& xcf_io, Layer& layer)
{
    TQ_INT32 width;
    TQ_INT32 height;
    TQ_INT32 bpp;
    TQ_UINT32 offset;
 
    xcf_io >> width >> height >> bpp >> offset;
 
    if (xcf_io.device()->status() != IO_Ok) {
        kdDebug(399) << "XCF: read failure on layer " << layer.name << " image header" << endl;
        return false;
    }
 
    // GIMP stores images in a "mipmap"-like format (multiple levels of
    // increasingly lower resolution). Only the top level is used here,
    // however.
 
    TQ_UINT32 junk;
    do {
        xcf_io >> junk;
 
        if (xcf_io.device()->status() != IO_Ok) {
            kdDebug(399) << "XCF: read failure on layer " << layer.name << " level offsets" << endl;
            return false;
        }
    } while (junk != 0);
 
    TQIODevice::Offset saved_pos = xcf_io.device()->at();
 
    xcf_io.device()->at(offset);
    if (!loadLevel(xcf_io, layer, bpp))
        return false;
 
    xcf_io.device()->at(saved_pos);
    return true;
}
 
 
bool XCFImageFormat::loadLevel(TQDataStream& xcf_io, Layer& layer, TQ_INT32 bpp)
{
    TQ_INT32 width;
    TQ_INT32 height;
    TQ_UINT32 offset;
 
    xcf_io >> width >> height >> offset;
 
    if (xcf_io.device()->status() != IO_Ok) {
        kdDebug(399) << "XCF: read failure on layer " << layer.name << " level info" << endl;
        return false;
    }
 
    if (offset == 0)
        return true;
 
    for (uint j = 0; j < layer.nrows; j++) {
        for (uint i = 0; i < layer.ncols; i++) {
 
            if (offset == 0) {
                kdDebug(399) << "XCF: incorrect number of tiles in layer " << layer.name << endl;
                return false;
            }
 
            TQIODevice::Offset saved_pos = xcf_io.device()->at();
            TQ_UINT32 offset2;
            xcf_io >> offset2;
 
            if (xcf_io.device()->status() != IO_Ok) {
                kdDebug(399) << "XCF: read failure on layer " << layer.name << " level offset look-ahead" << endl;
                return false;
            }
 
            // Evidently, RLE can occasionally expand a tile instead of compressing it!
 
            if (offset2 == 0)
                offset2 = offset + (uint)(TILE_WIDTH * TILE_HEIGHT * 4 * 1.5);
 
            xcf_io.device()->at(offset);
            int size = layer.image_tiles[j][i].width() * layer.image_tiles[j][i].height();
 
            if (!loadTileRLE(xcf_io, layer.tile, size, offset2 - offset, bpp))
                return false;
 
            // The bytes in the layer tile are juggled differently depending on
            // the target TQImage. The caller has set layer.assignBytes to the
            // appropriate routine.
 
            layer.assignBytes(layer, i, j);
 
            xcf_io.device()->at(saved_pos);
            xcf_io >> offset;
 
            if (xcf_io.device()->status() != IO_Ok) {
                kdDebug(399) << "XCF: read failure on layer " << layer.name << " level offset" << endl;
                return false;
            }
        }
    }
 
    return true;
}
 
 
bool XCFImageFormat::loadMask(TQDataStream& xcf_io, Layer& layer)
{
    TQ_INT32 width;
    TQ_INT32 height;
    char* name;
 
    xcf_io >> width >> height >> name;
 
    if (xcf_io.device()->status() != IO_Ok) {
        kdDebug(399) << "XCF: read failure on mask info" << endl;
        return false;
    }
 
    delete name;
 
    if (!loadChannelProperties(xcf_io, layer))
        return false;
 
    TQ_UINT32 hierarchy_offset;
    xcf_io >> hierarchy_offset;
 
    if (xcf_io.device()->status() != IO_Ok) {
        kdDebug(399) << "XCF: read failure on mask image offset" << endl;
        return false;
    }
 
    xcf_io.device()->at(hierarchy_offset);
    layer.assignBytes = assignMaskBytes;
 
    if (!loadHierarchy(xcf_io, layer))
        return false;
 
    return true;
}
 
 
bool XCFImageFormat::loadTileRLE(TQDataStream& xcf_io, uchar* tile, int image_size,
        int data_length, TQ_INT32 bpp)
{
    uchar* data;
 
    uchar* xcfdata;
    uchar* xcfodata;
    uchar* xcfdatalimit;
 
    xcfdata = xcfodata = new uchar[data_length];
 
    xcf_io.readRawBytes((char*)xcfdata, data_length);
 
    if (xcf_io.device()->status() != IO_Ok) {
        delete[] xcfodata;
        kdDebug(399) << "XCF: read failure on tile" << endl;
        return false;
    }
 
    xcfdatalimit = &xcfodata[data_length - 1];
 
    for (int i = 0; i < bpp; ++i) {
 
        data = tile + i;
 
        int count = 0;
        int size = image_size;
 
        while (size > 0) {
            if (xcfdata > xcfdatalimit)
                goto bogus_rle;
 
            uchar val = *xcfdata++;
            uint length = val;
 
            if (length >= 128) {
                length = 255 - (length - 1);
                if (length == 128) {
                    if (xcfdata >= xcfdatalimit)
                        goto bogus_rle;
 
                    length = (*xcfdata << 8) + xcfdata[1];
 
                    xcfdata += 2;
                }
 
                count += length;
                size -= length;
 
                if (size < 0)
                    goto bogus_rle;
 
                if (&xcfdata[length - 1] > xcfdatalimit)
                    goto bogus_rle;
 
                while (length-- > 0) {
                    *data = *xcfdata++;
                    data += sizeof(TQRgb);
                }
            } else {
                length += 1;
                if (length == 128) {
                    if (xcfdata >= xcfdatalimit)
                        goto bogus_rle;
 
                    length = (*xcfdata << 8) + xcfdata[1];
                    xcfdata += 2;
                }
 
                count += length;
                size -= length;
 
                if (size < 0)
                    goto bogus_rle;
 
                if (xcfdata > xcfdatalimit)
                    goto bogus_rle;
 
                val = *xcfdata++;
 
                while (length-- > 0) {
                    *data = val;
                    data += sizeof(TQRgb);
                }
            }
        }
    }
 
    delete[] xcfodata;
    return true;
 
bogus_rle:
 
    kdDebug(399) << "The run length encoding could not be decoded properly" << endl;
    delete[] xcfodata;
    return false;
}
 
 
bool XCFImageFormat::loadChannelProperties(TQDataStream& xcf_io, Layer& layer)
{
    while (true) {
        PropType type;
        TQByteArray bytes;
 
        if (!loadProperty(xcf_io, type, bytes)) {
            kdDebug(399) << "XCF: error loading channel properties" << endl;
            return false;
        }
 
        TQDataStream property(bytes, IO_ReadOnly);
 
        switch (type) {
            case PROP_END:
                return true;
 
            case PROP_OPACITY:
                property >> layer.mask_channel.opacity;
                break;
 
            case PROP_VISIBLE:
                property >> layer.mask_channel.visible;
                break;
 
            case PROP_SHOW_MASKED:
                property >> layer.mask_channel.show_masked;
                break;
 
            case PROP_COLOR:
                property >> layer.mask_channel.red >> layer.mask_channel.green
                        >> layer.mask_channel.blue;
                break;
 
            case PROP_TATTOO:
                property >> layer.mask_channel.tattoo;
                break;
 
            default:
                kdDebug(399) << "XCF: unimplemented channel property " << type
                        << ", size " << bytes.size() << endl;
        }
    }
}
 
 
void XCFImageFormat::assignMaskBytes(Layer& layer, uint i, uint j)
{
    uchar* tile = layer.tile;
 
    for (int l = 0; l < layer.image_tiles[j][i].height(); l++) {
        for (int k = 0; k < layer.image_tiles[j][i].width(); k++) {
            layer.mask_tiles[j][i].setPixel(k, l, tile[0]);
            tile += sizeof(TQRgb);
        }
    }
}
 
 
bool XCFImageFormat::initializeImage(XCFImage& xcf_image)
{
    // (Aliases to make the code look a little better.)
    Layer& layer(xcf_image.layer);
    TQImage& image(xcf_image.image);
 
    switch (layer.type) {
        case RGB_GIMAGE:
            if (layer.opacity == OPAQUE_OPACITY) {
                image.create( xcf_image.width, xcf_image.height, 32);
                if( image.isNull())
                    return false;
                image.fill(tqRgb(255, 255, 255));
                break;
            } // else, fall through to 32-bit representation
 
        case RGBA_GIMAGE:
            image.create(xcf_image.width, xcf_image.height, 32);
            if( image.isNull())
                return false;
            image.fill(tqRgba(255, 255, 255, 0));
            // Turning this on prevents fill() from affecting the alpha channel,
            // by the way.
            image.setAlphaBuffer(true);
            break;
 
        case GRAY_GIMAGE:
            if (layer.opacity == OPAQUE_OPACITY) {
                image.create(xcf_image.width, xcf_image.height, 8, 256);
                if( image.isNull())
                    return false;
                setGrayPalette(image);
                image.fill(255);
                break;
            } // else, fall through to 32-bit representation
 
        case GRAYA_GIMAGE:
            image.create(xcf_image.width, xcf_image.height, 32);
            if( image.isNull())
                return false;
            image.fill(tqRgba(255, 255, 255, 0));
            image.setAlphaBuffer(true);
            break;
 
        case INDEXED_GIMAGE:
            // As noted in the table above, there are quite a few combinations
            // which are possible with indexed images, depending on the
            // presense of transparency (note: not translucency, which is not
            // supported by The GIMP for indexed images) and the number of
            // individual colors.
 
            // Note: Qt treats a bitmap with a Black and White color palette
            // as a mask, so only the "on" bits are drawn, regardless of the
            // order color table entries. Otherwise (i.e., at least one of the
            // color table entries is not black or white), it obeys the one-
            // or two-color palette. Have to ask about this...
 
            if (xcf_image.num_colors <= 2) {
                image.create(xcf_image.width, xcf_image.height,
                        1, xcf_image.num_colors,
                        TQImage::LittleEndian);
                if( image.isNull())
                    return false;
                image.fill(0);
                setPalette(xcf_image, image);
            } else if (xcf_image.num_colors <= 256) {
                image.create(xcf_image.width, xcf_image.height,
                8, xcf_image.num_colors,
                TQImage::LittleEndian);
                if( image.isNull())
                    return false;
                image.fill(0);
                setPalette(xcf_image, image);
            }
            break;
 
        case INDEXEDA_GIMAGE:
            if (xcf_image.num_colors == 1) {
                // Plenty(!) of room to add a transparent color
                xcf_image.num_colors++;
                xcf_image.palette.resize(xcf_image.num_colors);
                xcf_image.palette[1] = xcf_image.palette[0];
                xcf_image.palette[0] = tqRgba(255, 255, 255, 0);
 
                image.create(xcf_image.width, xcf_image.height,
                        1, xcf_image.num_colors,
                        TQImage::LittleEndian);
                if( image.isNull())
                    return false;
                image.fill(0);
                setPalette(xcf_image, image);
                image.setAlphaBuffer(true);
            } else if (xcf_image.num_colors < 256) {
                // Plenty of room to add a transparent color
                xcf_image.num_colors++;
                xcf_image.palette.resize(xcf_image.num_colors);
                for (int c = xcf_image.num_colors - 1; c >= 1; c--)
                    xcf_image.palette[c] = xcf_image.palette[c - 1];
 
                xcf_image.palette[0] = tqRgba(255, 255, 255, 0);
                image.create( xcf_image.width, xcf_image.height,
                        8, xcf_image.num_colors);
                if( image.isNull())
                    return false;
                image.fill(0);
                setPalette(xcf_image, image);
                image.setAlphaBuffer(true);
            } else {
                // No room for a transparent color, so this has to be promoted to
                // true color. (There is no equivalent PNG representation output
                // from The GIMP as of v1.2.)
                image.create(xcf_image.width, xcf_image.height, 32);
                if( image.isNull())
                    return false;
                image.fill(tqRgba(255, 255, 255, 0));
                image.setAlphaBuffer(true);
            }
            break;
    }
 
    image.setDotsPerMeterX((int)(xcf_image.x_resolution * INCHESPERMETER));
    image.setDotsPerMeterY((int)(xcf_image.y_resolution * INCHESPERMETER));
    return true;
}
 
 
void XCFImageFormat::copyLayerToImage(XCFImage& xcf_image)
{
    Layer& layer(xcf_image.layer);
    TQImage& image(xcf_image.image);
    PixelCopyOperation copy = 0;
 
    switch (layer.type) {
        case RGB_GIMAGE:
        case RGBA_GIMAGE:
            copy = copyRGBToRGB;
            break;
        case GRAY_GIMAGE:
            if (layer.opacity == OPAQUE_OPACITY)
                copy = copyGrayToGray;
            else
                copy = copyGrayToRGB;
            break;
        case GRAYA_GIMAGE:
            copy = copyGrayAToRGB;
            break;
        case INDEXED_GIMAGE:
            copy = copyIndexedToIndexed;
            break;
        case INDEXEDA_GIMAGE:
            if (xcf_image.image.depth() <= 8)
                copy = copyIndexedAToIndexed;
            else
                copy = copyIndexedAToRGB;
    }
 
    // For each tile...
 
    for (uint j = 0; j < layer.nrows; j++) {
        uint y = j * TILE_HEIGHT;
 
        for (uint i = 0; i < layer.ncols; i++) {
            uint x = i * TILE_WIDTH;
 
            // This seems the best place to apply the dissolve because it
            // depends on the global position of each tile's
            // pixels. Apparently it's the only mode which can apply to a
            // single layer.
 
            if (layer.mode == DISSOLVE_MODE) {
                if (layer.type == RGBA_GIMAGE)
                    dissolveRGBPixels(layer.image_tiles[j][i], x, y);
 
                else if (layer.type == GRAYA_GIMAGE)
                    dissolveAlphaPixels(layer.alpha_tiles[j][i], x, y);
            }
 
            for (int l = 0; l < layer.image_tiles[j][i].height(); l++) {
                for (int k = 0; k < layer.image_tiles[j][i].width(); k++) {
 
                    int m = x + k + layer.x_offset;
                    int n = y + l + layer.y_offset;
 
                    if (m < 0 || m >= image.width() || n < 0 || n >= image.height())
                        continue;
 
                    (*copy)(layer, i, j, k, l, image, m, n);
                }
            }
        }
    }
}
 
 
void XCFImageFormat::copyRGBToRGB(Layer& layer, uint i, uint j, int k, int l,
        TQImage& image, int m, int n)
{
    TQRgb src = layer.image_tiles[j][i].pixel(k, l);
    uchar src_a = layer.opacity;
 
    if (layer.type == RGBA_GIMAGE)
        src_a = INT_MULT(src_a, tqAlpha(src));
 
    // Apply the mask (if any)
 
    if (layer.apply_mask == 1 && layer.mask_tiles.size() > j &&
            layer.mask_tiles[j].size() > i)
        src_a = INT_MULT(src_a, layer.mask_tiles[j][i].pixelIndex(k, l));
 
    image.setPixel(m, n, tqRgba(src, src_a));
}
 
 
void XCFImageFormat::copyGrayToGray(Layer& layer, uint i, uint j, int k, int l,
        TQImage& image, int m, int n)
{
    int src = layer.image_tiles[j][i].pixelIndex(k, l);
    image.setPixel(m, n, src);
}
 
 
void XCFImageFormat::copyGrayToRGB(Layer& layer, uint i, uint j, int k, int l,
        TQImage& image, int m, int n)
{
    TQRgb src = layer.image_tiles[j][i].pixel(k, l);
    uchar src_a = layer.opacity;
    image.setPixel(m, n, tqRgba(src, src_a));
}
 
 
void XCFImageFormat::copyGrayAToRGB(Layer& layer, uint i, uint j, int k, int l,
                      TQImage& image, int m, int n)
{
    TQRgb src = layer.image_tiles[j][i].pixel(k, l);
    uchar src_a = layer.alpha_tiles[j][i].pixelIndex(k, l);
    src_a = INT_MULT(src_a, layer.opacity);
 
    // Apply the mask (if any)
 
    if (layer.apply_mask == 1 && layer.mask_tiles.size() > j &&
            layer.mask_tiles[j].size() > i)
        src_a = INT_MULT(src_a, layer.mask_tiles[j][i].pixelIndex(k, l));
 
    image.setPixel(m, n, tqRgba(src, src_a));
}
 
 
void XCFImageFormat::copyIndexedToIndexed(Layer& layer, uint i, uint j, int k, int l,
        TQImage& image, int m, int n)
{
    int src = layer.image_tiles[j][i].pixelIndex(k, l);
    image.setPixel(m, n, src);
}
 
 
void XCFImageFormat::copyIndexedAToIndexed(Layer& layer, uint i, uint j, int k, int l,
        TQImage& image, int m, int n)
{
    uchar src = layer.image_tiles[j][i].pixelIndex(k, l);
    uchar src_a = layer.alpha_tiles[j][i].pixelIndex(k, l);
    src_a = INT_MULT(src_a, layer.opacity);
 
    if (layer.apply_mask == 1 &&
            layer.mask_tiles.size() > j &&
            layer.mask_tiles[j].size() > i)
        src_a = INT_MULT(src_a, layer.mask_tiles[j][i].pixelIndex(k, l));
 
    if (src_a > 127)
        src++;
    else
        src = 0;
 
image.setPixel(m, n, src);
}
 
 
void XCFImageFormat::copyIndexedAToRGB(Layer& layer, uint i, uint j, int k, int l,
        TQImage& image, int m, int n)
{
    TQRgb src = layer.image_tiles[j][i].pixel(k, l);
    uchar src_a = layer.alpha_tiles[j][i].pixelIndex(k, l);
    src_a = INT_MULT(src_a, layer.opacity);
 
    // Apply the mask (if any)
    if (layer.apply_mask == 1 && layer.mask_tiles.size() > j &&
            layer.mask_tiles[j].size() > i)
        src_a = INT_MULT(src_a, layer.mask_tiles[j][i].pixelIndex(k, l));
 
    // This is what appears in the GIMP window
    if (src_a <= 127)
        src_a = 0;
    else
        src_a = OPAQUE_OPACITY;
 
    image.setPixel(m, n, tqRgba(src, src_a));
}
 
 
void XCFImageFormat::mergeLayerIntoImage(XCFImage& xcf_image)
{
    Layer& layer(xcf_image.layer);
    TQImage& image(xcf_image.image);
 
    PixelMergeOperation merge = 0;
 
    switch (layer.type) {
        case RGB_GIMAGE:
        case RGBA_GIMAGE:
            merge = mergeRGBToRGB;
            break;
        case GRAY_GIMAGE:
            if (layer.opacity == OPAQUE_OPACITY)
                merge = mergeGrayToGray;
            else
                merge = mergeGrayToRGB;
            break;
        case GRAYA_GIMAGE:
            if (xcf_image.image.depth() <= 8)
                merge = mergeGrayAToGray;
            else
                merge = mergeGrayAToRGB;
            break;
        case INDEXED_GIMAGE:
            merge = mergeIndexedToIndexed;
            break;
        case INDEXEDA_GIMAGE:
            if (xcf_image.image.depth() <= 8)
                merge = mergeIndexedAToIndexed;
            else
                merge = mergeIndexedAToRGB;
    }
 
    for (uint j = 0; j < layer.nrows; j++) {
        uint y = j * TILE_HEIGHT;
 
        for (uint i = 0; i < layer.ncols; i++) {
            uint x = i * TILE_WIDTH;
 
            // This seems the best place to apply the dissolve because it
            // depends on the global position of each tile's
            // pixels. Apparently it's the only mode which can apply to a
            // single layer.
 
            if (layer.mode == DISSOLVE_MODE) {
                if (layer.type == RGBA_GIMAGE)
                    dissolveRGBPixels(layer.image_tiles[j][i], x, y);
 
                else if (layer.type == GRAYA_GIMAGE)
                    dissolveAlphaPixels(layer.alpha_tiles[j][i], x, y);
            }
 
            for (int l = 0; l < layer.image_tiles[j][i].height(); l++) {
                for (int k = 0; k < layer.image_tiles[j][i].width(); k++) {
 
                    int m = x + k + layer.x_offset;
                    int n = y + l + layer.y_offset;
 
                    if (m < 0 || m >= image.width() || n < 0 || n >= image.height())
                        continue;
 
                    (*merge)(layer, i, j, k, l, image, m, n);
                }
            }
        }
    }
}
 
 
void XCFImageFormat::mergeRGBToRGB(Layer& layer, uint i, uint j, int k, int l,
        TQImage& image, int m, int n)
{
    TQRgb src = layer.image_tiles[j][i].pixel(k, l);
    TQRgb dst = image.pixel(m, n);
 
    uchar src_r = tqRed(src);
    uchar src_g = tqGreen(src);
    uchar src_b = tqBlue(src);
    uchar src_a = tqAlpha(src);
 
    uchar dst_r = tqRed(dst);
    uchar dst_g = tqGreen(dst);
    uchar dst_b = tqBlue(dst);
    uchar dst_a = tqAlpha(dst);
 
    switch (layer.mode) {
        case MULTIPLY_MODE: {
            src_r = INT_MULT(src_r, dst_r);
            src_g = INT_MULT(src_g, dst_g);
            src_b = INT_MULT(src_b, dst_b);
            src_a = KMIN(src_a, dst_a);
            }
            break;
        case DIVIDE_MODE: {
            src_r = KMIN((dst_r * 256) / (1 + src_r), 255);
            src_g = KMIN((dst_g * 256) / (1 + src_g), 255);
            src_b = KMIN((dst_b * 256) / (1 + src_b), 255);
            src_a = KMIN(src_a, dst_a);
            }
            break;
        case SCREEN_MODE: {
            src_r = 255 - INT_MULT(255 - dst_r, 255 - src_r);
            src_g = 255 - INT_MULT(255 - dst_g, 255 - src_g);
            src_b = 255 - INT_MULT(255 - dst_b, 255 - src_b);
            src_a = KMIN(src_a, dst_a);
            }
            break;
        case OVERLAY_MODE: {
            src_r = INT_MULT(dst_r, dst_r + INT_MULT(2 * src_r, 255 - dst_r));
            src_g = INT_MULT(dst_g, dst_g + INT_MULT(2 * src_g, 255 - dst_g));
            src_b = INT_MULT(dst_b, dst_b + INT_MULT(2 * src_b, 255 - dst_b));
            src_a = KMIN(src_a, dst_a);
            }
            break;
        case DIFFERENCE_MODE: {
            src_r = dst_r > src_r ? dst_r - src_r : src_r - dst_r;
            src_g = dst_g > src_g ? dst_g - src_g : src_g - dst_g;
            src_b = dst_b > src_b ? dst_b - src_b : src_b - dst_b;
            src_a = KMIN(src_a, dst_a);
            }
            break;
        case ADDITION_MODE: {
              src_r = add_lut(dst_r,src_r);
              src_g = add_lut(dst_g,src_g);
              src_b = add_lut(dst_b,src_b);
              src_a = KMIN(src_a, dst_a);
            }
            break;
        case SUBTRACT_MODE: {
            src_r = dst_r > src_r ? dst_r - src_r : 0;
            src_g = dst_g > src_g ? dst_g - src_g : 0;
            src_b = dst_b > src_b ? dst_b - src_b : 0;
            src_a = KMIN(src_a, dst_a);
            }
            break;
        case DARKEN_ONLY_MODE: {
            src_r = dst_r < src_r ? dst_r : src_r;
            src_g = dst_g < src_g ? dst_g : src_g;
            src_b = dst_b < src_b ? dst_b : src_b;
            src_a = KMIN( src_a, dst_a );
            }
            break;
        case LIGHTEN_ONLY_MODE: {
            src_r = dst_r < src_r ? src_r : dst_r;
            src_g = dst_g < src_g ? src_g : dst_g;
            src_b = dst_b < src_b ? src_b : dst_b;
            src_a = KMIN(src_a, dst_a);
            }
            break;
        case HUE_MODE: {
            uchar new_r = dst_r;
            uchar new_g = dst_g;
            uchar new_b = dst_b;
 
            RGBTOHSV(src_r, src_g, src_b);
            RGBTOHSV(new_r, new_g, new_b);
 
            new_r = src_r;
 
            HSVTORGB(new_r, new_g, new_b);
 
            src_r = new_r;
            src_g = new_g;
            src_b = new_b;
            src_a = KMIN( src_a, dst_a );
            }
            break;
        case SATURATION_MODE: {
            uchar new_r = dst_r;
            uchar new_g = dst_g;
            uchar new_b = dst_b;
 
            RGBTOHSV(src_r, src_g, src_b);
            RGBTOHSV(new_r, new_g, new_b);
 
            new_g = src_g;
 
            HSVTORGB(new_r, new_g, new_b);
 
            src_r = new_r;
            src_g = new_g;
            src_b = new_b;
            src_a = KMIN(src_a, dst_a);
            }
            break;
        case VALUE_MODE: {
            uchar new_r = dst_r;
            uchar new_g = dst_g;
            uchar new_b = dst_b;
 
            RGBTOHSV(src_r, src_g, src_b);
            RGBTOHSV(new_r, new_g, new_b);
 
            new_b = src_b;
 
            HSVTORGB(new_r, new_g, new_b);
 
            src_r = new_r;
            src_g = new_g;
            src_b = new_b;
            src_a = KMIN(src_a, dst_a);
            }
            break;
        case COLOR_MODE: {
            uchar new_r = dst_r;
            uchar new_g = dst_g;
            uchar new_b = dst_b;
 
            RGBTOHLS(src_r, src_g, src_b);
            RGBTOHLS(new_r, new_g, new_b);
 
            new_r = src_r;
            new_b = src_b;
 
            HLSTORGB(new_r, new_g, new_b);
 
            src_r = new_r;
            src_g = new_g;
            src_b = new_b;
            src_a = KMIN(src_a, dst_a);
            }
            break;
    }
 
    src_a = INT_MULT(src_a, layer.opacity);
 
    // Apply the mask (if any)
 
    if (layer.apply_mask == 1 && layer.mask_tiles.size() > j &&
            layer.mask_tiles[j].size() > i)
        src_a = INT_MULT(src_a, layer.mask_tiles[j][i].pixelIndex(k, l));
 
    uchar new_r, new_g, new_b, new_a;
    new_a = dst_a + INT_MULT(OPAQUE_OPACITY - dst_a, src_a);
 
    float src_ratio = (float)src_a / new_a;
    float dst_ratio = 1.0 - src_ratio;
 
    new_r = (uchar)(src_ratio * src_r + dst_ratio * dst_r + EPSILON);
    new_g = (uchar)(src_ratio * src_g + dst_ratio * dst_g + EPSILON);
    new_b = (uchar)(src_ratio * src_b + dst_ratio * dst_b + EPSILON);
 
    if (!layer_modes[layer.mode].affect_alpha)
        new_a = dst_a;
 
    image.setPixel(m, n, tqRgba(new_r, new_g, new_b, new_a));
}
 
 
void XCFImageFormat::mergeGrayToGray(Layer& layer, uint i, uint j, int k, int l,
        TQImage& image, int m, int n)
{
    int src = layer.image_tiles[j][i].pixelIndex(k, l);
    image.setPixel(m, n, src);
}
 
 
void XCFImageFormat::mergeGrayAToGray(Layer& layer, uint i, uint j, int k, int l,
        TQImage& image, int m, int n)
{
    int src = tqGray(layer.image_tiles[j][i].pixel(k, l));
    int dst = image.pixelIndex(m, n);
 
    uchar src_a = layer.alpha_tiles[j][i].pixelIndex(k, l);
 
    switch (layer.mode) {
        case MULTIPLY_MODE: {
                src = INT_MULT( src, dst );
            }
            break;
        case DIVIDE_MODE: {
                src = KMIN((dst * 256) / (1 + src), 255);
            }
            break;
        case SCREEN_MODE: {
                src = 255 - INT_MULT(255 - dst, 255 - src);
            }
            break;
        case OVERLAY_MODE: {
                src = INT_MULT(dst, dst + INT_MULT(2 * src, 255 - dst));
            }
            break;
        case DIFFERENCE_MODE: {
                src = dst > src ? dst - src : src - dst;
            }
            break;
        case ADDITION_MODE: {
                src = add_lut(dst,src);
            }
            break;
        case SUBTRACT_MODE: {
                src = dst > src ? dst - src : 0;
            }
            break;
        case DARKEN_ONLY_MODE: {
                src = dst < src ? dst : src;
            }
            break;
        case LIGHTEN_ONLY_MODE: {
                src = dst < src ? src : dst;
            }
            break;
    }
 
    src_a = INT_MULT(src_a, layer.opacity);
 
    // Apply the mask (if any)
 
    if (layer.apply_mask == 1 && layer.mask_tiles.size() > j &&
            layer.mask_tiles[j].size() > i)
        src_a = INT_MULT(src_a, layer.mask_tiles[j][i].pixelIndex(k, l));
 
    uchar new_a = OPAQUE_OPACITY;
 
    float src_ratio = (float)src_a / new_a;
    float dst_ratio = 1.0 - src_ratio;
 
    uchar new_g = (uchar)(src_ratio * src + dst_ratio * dst + EPSILON);
 
    image.setPixel(m, n, new_g);
}
 
 
void XCFImageFormat::mergeGrayToRGB(Layer& layer, uint i, uint j, int k, int l,
        TQImage& image, int m, int n)
{
    TQRgb src = layer.image_tiles[j][i].pixel(k, l);
    uchar src_a = layer.opacity;
    image.setPixel(m, n, tqRgba(src, src_a));
}
 
 
void XCFImageFormat::mergeGrayAToRGB(Layer& layer, uint i, uint j, int k, int l,
        TQImage& image, int m, int n)
{
    int src = tqGray(layer.image_tiles[j][i].pixel(k, l));
    int dst = tqGray(image.pixel(m, n));
 
    uchar src_a = layer.alpha_tiles[j][i].pixelIndex(k, l);
    uchar dst_a = tqAlpha(image.pixel(m, n));
 
    switch (layer.mode) {
        case MULTIPLY_MODE: {
                src = INT_MULT(src, dst);
                src_a = KMIN(src_a, dst_a);
            }
            break;
        case DIVIDE_MODE: {
                src = KMIN((dst * 256) / (1 + src), 255);
                src_a = KMIN(src_a, dst_a);
            }
            break;
        case SCREEN_MODE: {
                src = 255 - INT_MULT(255 - dst, 255 - src);
                src_a = KMIN(src_a, dst_a);
            }
            break;
        case OVERLAY_MODE: {
                src = INT_MULT( dst, dst + INT_MULT(2 * src, 255 - dst));
                src_a = KMIN(src_a, dst_a);
            }
            break;
        case DIFFERENCE_MODE: {
                src = dst > src ? dst - src : src - dst;
                src_a = KMIN(src_a, dst_a);
            }
            break;
        case ADDITION_MODE: {
                src = add_lut(dst,src);
                src_a = KMIN(src_a, dst_a);
            }
            break;
        case SUBTRACT_MODE: {
                src = dst > src ? dst - src : 0;
                src_a = KMIN(src_a, dst_a);
            }
            break;
        case DARKEN_ONLY_MODE: {
                src = dst < src ? dst : src;
                src_a = KMIN(src_a, dst_a);
            }
            break;
        case LIGHTEN_ONLY_MODE: {
                src = dst < src ? src : dst;
                src_a = KMIN(src_a, dst_a);
            }
            break;
    }
 
    src_a = INT_MULT(src_a, layer.opacity);
 
    // Apply the mask (if any)
    if (layer.apply_mask == 1 && layer.mask_tiles.size() > j &&
            layer.mask_tiles[j].size() > i)
        src_a = INT_MULT(src_a, layer.mask_tiles[j][i].pixelIndex(k, l));
 
    uchar new_a = dst_a + INT_MULT(OPAQUE_OPACITY - dst_a, src_a);
 
    float src_ratio = (float)src_a / new_a;
    float dst_ratio = 1.0 - src_ratio;
 
    uchar new_g = (uchar)(src_ratio * src + dst_ratio * dst + EPSILON);
 
    if (!layer_modes[layer.mode].affect_alpha)
        new_a = dst_a;
 
    image.setPixel(m, n, tqRgba(new_g, new_g, new_g, new_a));
}
 
 
void XCFImageFormat::mergeIndexedToIndexed(Layer& layer, uint i, uint j, int k, int l,
        TQImage& image, int m, int n)
{
    int src = layer.image_tiles[j][i].pixelIndex(k, l);
    image.setPixel(m, n, src);
}
 
 
void XCFImageFormat::mergeIndexedAToIndexed(Layer& layer, uint i, uint j, int k, int l,
        TQImage& image, int m, int n)
{
    uchar src = layer.image_tiles[j][i].pixelIndex(k, l);
    uchar src_a = layer.alpha_tiles[j][i].pixelIndex(k, l);
    src_a = INT_MULT( src_a, layer.opacity );
 
    if ( layer.apply_mask == 1 &&
            layer.mask_tiles.size() > j &&
            layer.mask_tiles[j].size() > i)
        src_a = INT_MULT(src_a, layer.mask_tiles[j][i].pixelIndex(k, l));
 
    if (src_a > 127) {
        src++;
        image.setPixel(m, n, src);
    }
}
 
 
void XCFImageFormat::mergeIndexedAToRGB(Layer& layer, uint i, uint j, int k, int l,
        TQImage& image, int m, int n)
{
    TQRgb src = layer.image_tiles[j][i].pixel(k, l);
    uchar src_a = layer.alpha_tiles[j][i].pixelIndex(k, l);
    src_a = INT_MULT(src_a, layer.opacity);
 
    // Apply the mask (if any)
    if (layer.apply_mask == 1 && layer.mask_tiles.size() > j &&
            layer.mask_tiles[j].size() > i)
        src_a = INT_MULT(src_a, layer.mask_tiles[j][i].pixelIndex(k, l));
 
    // This is what appears in the GIMP window
    if (src_a <= 127)
        src_a = 0;
    else
        src_a = OPAQUE_OPACITY;
 
    image.setPixel(m, n, tqRgba(src, src_a));
}
 
 
void XCFImageFormat::dissolveRGBPixels ( TQImage& image, int x, int y )
{
    // The apparently spurious rand() calls are to wind the random
    // numbers up to the same point for each tile.
 
    for (int l = 0; l < image.height(); l++) {
        srand(random_table[( l + y ) % RANDOM_TABLE_SIZE]);
 
        for (int k = 0; k < x; k++)
            rand();
 
        for (int k = 0; k < image.width(); k++) {
            int rand_val = rand() & 0xff;
            TQRgb pixel = image.pixel(k, l);
 
            if (rand_val > tqAlpha(pixel)) {
                image.setPixel(k, l, tqRgba(pixel, 0));
            }
        }
    }
}
 
 
void XCFImageFormat::dissolveAlphaPixels ( TQImage& image, int x, int y )
{
    // The apparently spurious rand() calls are to wind the random
    // numbers up to the same point for each tile.
 
    for (int l = 0; l < image.height(); l++) {
        srand( random_table[(l + y) % RANDOM_TABLE_SIZE]);
 
        for (int k = 0; k < x; k++)
            rand();
 
        for (int k = 0; k < image.width(); k++) {
            int rand_val = rand() & 0xff;
            uchar alpha = image.pixelIndex(k, l);
 
            if (rand_val > alpha) {
                image.setPixel(k, l, 0);
            }
        }
    }
}