You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
232 lines
8.9 KiB
232 lines
8.9 KiB
#ifndef XCF_H
|
|
#define XCF_H
|
|
/*
|
|
* 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 <tqimage.h>
|
|
#include <tqiodevice.h>
|
|
#include <tqvaluestack.h>
|
|
#include <tqvaluevector.h>
|
|
|
|
#include "gimp.h"
|
|
|
|
|
|
extern "C" {
|
|
void kimgio_xcf_read(TQImageIO *);
|
|
void kimgio_xcf_write(TQImageIO *);
|
|
}
|
|
|
|
const float INCHESPERMETER = (100.0 / 2.54);
|
|
|
|
/*!
|
|
* Each layer in an XCF file is stored as a matrix of
|
|
* 64-pixel by 64-pixel images. The GIMP has a sophisticated
|
|
* method of handling very large images as well as implementing
|
|
* parallel processing on a tile-by-tile basis. Here, though,
|
|
* we just read them in en-masse and store them in a matrix.
|
|
*/
|
|
typedef TQValueVector<TQValueVector<TQImage> > Tiles;
|
|
|
|
|
|
|
|
class XCFImageFormat {
|
|
public:
|
|
XCFImageFormat();
|
|
void readXCF(TQImageIO* image_io);
|
|
|
|
|
|
private:
|
|
/*!
|
|
* Each GIMP image is composed of one or more layers. A layer can
|
|
* be one of any three basic types: RGB, grayscale or indexed. With an
|
|
* optional alpha channel, there are six possible types altogether.
|
|
*
|
|
* Note: there is only ever one instance of this structure. The
|
|
* layer info is discarded after it is merged into the final TQImage.
|
|
*/
|
|
class Layer {
|
|
public:
|
|
TQ_UINT32 width; //!< Width of the layer
|
|
TQ_UINT32 height; //!< Height of the layer
|
|
TQ_INT32 type; //!< Type of the layer (GimpImageType)
|
|
char* name; //!< Name of the layer
|
|
TQ_UINT32 hierarchy_offset; //!< File position of Tile hierarchy
|
|
TQ_UINT32 mask_offset; //!< File position of mask image
|
|
|
|
uint nrows; //!< Number of rows of tiles (y direction)
|
|
uint ncols; //!< Number of columns of tiles (x direction)
|
|
|
|
Tiles image_tiles; //!< The basic image
|
|
//! For Grayscale and Indexed images, the alpha channel is stored
|
|
//! separately (in this data structure, anyway).
|
|
Tiles alpha_tiles;
|
|
Tiles mask_tiles; //!< The layer mask (optional)
|
|
|
|
//! Additional information about a layer mask.
|
|
struct {
|
|
TQ_UINT32 opacity;
|
|
TQ_UINT32 visible;
|
|
TQ_UINT32 show_masked;
|
|
uchar red, green, blue;
|
|
TQ_UINT32 tattoo;
|
|
} mask_channel;
|
|
|
|
bool active; //!< Is this layer the active layer?
|
|
TQ_UINT32 opacity; //!< The opacity of the layer
|
|
TQ_UINT32 visible; //!< Is the layer visible?
|
|
TQ_UINT32 linked; //!< Is this layer linked (geometrically)
|
|
TQ_UINT32 preserve_transparency; //!< Preserve alpha when drawing on layer?
|
|
TQ_UINT32 apply_mask; //!< Apply the layer mask?
|
|
TQ_UINT32 edit_mask; //!< Is the layer mask the being edited?
|
|
TQ_UINT32 show_mask; //!< Show the layer mask rather than the image?
|
|
TQ_INT32 x_offset; //!< x offset of the layer relative to the image
|
|
TQ_INT32 y_offset; //!< y offset of the layer relative to the image
|
|
TQ_UINT32 mode; //!< Combining mode of layer (LayerModeEffects)
|
|
TQ_UINT32 tattoo; //!< (unique identifier?)
|
|
|
|
//! As each tile is read from the file, it is buffered here.
|
|
uchar tile[TILE_WIDTH * TILE_HEIGHT * sizeof(QRgb)];
|
|
|
|
//! The data from tile buffer is copied to the Tile by this
|
|
//! method. Depending on the type of the tile (RGB, Grayscale,
|
|
//! Indexed) and use (image or mask), the bytes in the buffer are
|
|
//! copied in different ways.
|
|
void (*assignBytes)(Layer& layer, uint i, uint j);
|
|
|
|
Layer(void) : name(0) {}
|
|
~Layer(void) { delete[] name; }
|
|
};
|
|
|
|
|
|
/*!
|
|
* The in-memory representation of the XCF Image. It contains a few
|
|
* metadata items, but is mostly a container for the layer information.
|
|
*/
|
|
class XCFImage {
|
|
public:
|
|
TQ_UINT32 width; //!< width of the XCF image
|
|
TQ_UINT32 height; //!< height of the XCF image
|
|
TQ_INT32 type; //!< type of the XCF image (GimpImageBaseType)
|
|
|
|
TQ_UINT8 compression; //!< tile compression method (CompressionType)
|
|
float x_resolution; //!< x resolution in dots per inch
|
|
float y_resolution; //!< y resolution in dots per inch
|
|
TQ_INT32 tattoo; //!< (unique identifier?)
|
|
TQ_UINT32 unit; //!< Units of The GIMP (inch, mm, pica, etc...)
|
|
TQ_INT32 num_colors; //!< number of colors in an indexed image
|
|
TQValueVector<QRgb> palette; //!< indexed image color palette
|
|
|
|
int num_layers; //!< number of layers
|
|
Layer layer; //!< most recently read layer
|
|
|
|
bool initialized; //!< Is the TQImage initialized?
|
|
TQImage image; //!< final QImage
|
|
|
|
XCFImage(void) : initialized(false) {}
|
|
};
|
|
|
|
|
|
//! In layer DISSOLVE mode, a random number is chosen to compare to a
|
|
//! pixel's alpha. If the alpha is greater than the random number, the
|
|
//! pixel is drawn. This table merely contains the random number seeds
|
|
//! for each ROW of an image. Therefore, the random numbers chosen
|
|
//! are consistent from run to run.
|
|
static int random_table[RANDOM_TABLE_SIZE];
|
|
|
|
//! This table provides the add_pixel saturation values (i.e. 250 + 250 = 255).
|
|
//static int add_lut[256][256]; - this is so lame waste of 256k of memory
|
|
static int add_lut( int, int );
|
|
|
|
//! The bottom-most layer is copied into the final TQImage by this
|
|
//! routine.
|
|
typedef void (*PixelCopyOperation)(Layer& layer, uint i, uint j, int k, int l,
|
|
TQImage& image, int m, int n);
|
|
|
|
//! Higher layers are merged into the the final TQImage by this routine.
|
|
typedef void (*PixelMergeOperation)(Layer& layer, uint i, uint j, int k, int l,
|
|
TQImage& image, int m, int n);
|
|
|
|
//! Layer mode static data.
|
|
typedef struct {
|
|
bool affect_alpha; //!< Does this mode affect the source alpha?
|
|
} LayerModes;
|
|
|
|
//! Array of layer mode structures for the modes described by
|
|
//! LayerModeEffects.
|
|
static const LayerModes layer_modes[];
|
|
|
|
bool loadImageProperties(TQDataStream& xcf_io, XCFImage& image);
|
|
bool loadProperty(TQDataStream& xcf_io, PropType& type, TQByteArray& bytes);
|
|
bool loadLayer(TQDataStream& xcf_io, XCFImage& xcf_image);
|
|
bool loadLayerProperties(TQDataStream& xcf_io, Layer& layer);
|
|
bool composeTiles(XCFImage& xcf_image);
|
|
void setGrayPalette(TQImage& image);
|
|
void setPalette(XCFImage& xcf_image, TQImage& image);
|
|
static void assignImageBytes(Layer& layer, uint i, uint j);
|
|
bool loadHierarchy(TQDataStream& xcf_io, Layer& layer);
|
|
bool loadLevel(TQDataStream& xcf_io, Layer& layer, TQ_INT32 bpp);
|
|
static void assignMaskBytes(Layer& layer, uint i, uint j);
|
|
bool loadMask(TQDataStream& xcf_io, Layer& layer);
|
|
bool loadChannelProperties(TQDataStream& xcf_io, Layer& layer);
|
|
bool initializeImage(XCFImage& xcf_image);
|
|
bool loadTileRLE(TQDataStream& xcf_io, uchar* tile, int size,
|
|
int data_length, TQ_INT32 bpp);
|
|
static void copyLayerToImage(XCFImage& xcf_image);
|
|
static void copyRGBToRGB(Layer& layer, uint i, uint j, int k, int l,
|
|
TQImage& image, int m, int n);
|
|
|
|
static void copyGrayToGray(Layer& layer, uint i, uint j, int k, int l,
|
|
TQImage& image, int m, int n);
|
|
static void copyGrayToRGB(Layer& layer, uint i, uint j, int k, int l,
|
|
TQImage& image, int m, int n);
|
|
static void copyGrayAToRGB(Layer& layer, uint i, uint j, int k, int l,
|
|
TQImage& image, int m, int n);
|
|
static void copyIndexedToIndexed(Layer& layer, uint i, uint j, int k, int l,
|
|
TQImage& image, int m, int n);
|
|
static void copyIndexedAToIndexed(Layer& layer, uint i, uint j, int k, int l,
|
|
TQImage& image, int m, int n);
|
|
static void copyIndexedAToRGB(Layer& layer, uint i, uint j, int k, int l,
|
|
TQImage& image, int m, int n);
|
|
|
|
static void mergeLayerIntoImage(XCFImage& xcf_image);
|
|
static void mergeRGBToRGB(Layer& layer, uint i, uint j, int k, int l,
|
|
TQImage& image, int m, int n);
|
|
static void mergeGrayToGray(Layer& layer, uint i, uint j, int k, int l,
|
|
TQImage& image, int m, int n);
|
|
static void mergeGrayAToGray(Layer& layer, uint i, uint j, int k, int l,
|
|
TQImage& image, int m, int n);
|
|
static void mergeGrayToRGB(Layer& layer, uint i, uint j, int k, int l,
|
|
TQImage& image, int m, int n);
|
|
static void mergeGrayAToRGB(Layer& layer, uint i, uint j, int k, int l,
|
|
TQImage& image, int m, int n);
|
|
static void mergeIndexedToIndexed(Layer& layer, uint i, uint j, int k, int l,
|
|
TQImage& image, int m, int n);
|
|
static void mergeIndexedAToIndexed(Layer& layer, uint i, uint j, int k, int l,
|
|
TQImage& image, int m, int n);
|
|
static void mergeIndexedAToRGB(Layer& layer, uint i, uint j, int k, int l,
|
|
TQImage& image, int m, int n);
|
|
|
|
static void dissolveRGBPixels(TQImage& image, int x, int y);
|
|
static void dissolveAlphaPixels(TQImage& image, int x, int y);
|
|
};
|
|
|
|
#endif
|