mirror/kimageformats
1
0
Fork 0
mirror of https://invent.kde.org/frameworks/kimageformats.git synced 2025-05-27 08:20:21 -04:00
Code Issues Packages Projects Releases Wiki Activity

Code reformatted using kde-dev-scripts/astyle-kdelibs.

Browse Source 
Use git blame -w 47df948 to show authorship as it was before this commit.
This commit is contained in:
David Faure 2013-12-18 09:54:11 +01:00
parent 47df9483fd
commit 02b5e97197
19 changed files with 950 additions and 731 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

126
src/imageformats/dds.cpp
View File

@ -79,7 +79,6 @@ union Color4444 {
ushort u;
};
static const uint FOURCC_DDS = MAKEFOURCC('D', 'D', 'S', ' ');
static const uint FOURCC_DXT1 = MAKEFOURCC('D', 'X', 'T', '1');
static const uint FOURCC_DXT2 = MAKEFOURCC('D', 'X', 'T', '2');
@ -126,7 +125,6 @@ enum DDSType {
DDS_UNKNOWN
};
struct DDSPixelFormat {
uint size;
uint flags;
@ -138,7 +136,7 @@ struct DDSPixelFormat {
uint amask;
};
static QDataStream & operator>> (QDataStream & s, DDSPixelFormat & pf)
static QDataStream &operator>> (QDataStream &s, DDSPixelFormat &pf)
{
s >> pf.size;
s >> pf.flags;
@ -158,7 +156,7 @@ struct DDSCaps {
uint caps4;
};
static QDataStream & operator>> (QDataStream & s, DDSCaps & caps)
static QDataStream &operator>> (QDataStream &s, DDSCaps &caps)
{
s >> caps.caps1;
s >> caps.caps2;
@ -181,7 +179,7 @@ struct DDSHeader {
uint notused;
};
static QDataStream & operator>> (QDataStream & s, DDSHeader & header)
static QDataStream &operator>> (QDataStream &s, DDSHeader &header)
{
s >> header.size;
s >> header.flags;
@ -199,7 +197,7 @@ static QDataStream & operator>> (QDataStream & s, DDSHeader & header)
return s;
}
static bool IsValid(const DDSHeader & header)
static bool IsValid(const DDSHeader &header)
{
if (header.size != 124) {
return false;
@ -217,9 +215,8 @@ static bool IsValid(const DDSHeader & header)
return true;
}
// Get supported type. We currently support 10 different types.
static DDSType GetType(const DDSHeader & header)
static DDSType GetType(const DDSHeader &header)
{
if (header.pf.flags & DDPF_RGB) {
if (header.pf.flags & DDPF_ALPHAPIXELS) {
@ -258,17 +255,17 @@ static DDSType GetType(const DDSHeader & header)
return DDS_UNKNOWN;
}
static bool HasAlpha(const DDSHeader & header)
static bool HasAlpha(const DDSHeader &header)
{
return header.pf.flags & DDPF_ALPHAPIXELS;
}
static bool IsCubeMap(const DDSHeader & header)
static bool IsCubeMap(const DDSHeader &header)
{
return header.caps.caps2 & DDSCAPS2_CUBEMAP;
}
static bool IsSupported(const DDSHeader & header)
static bool IsSupported(const DDSHeader &header)
{
if (header.caps.caps2 & DDSCAPS2_VOLUME) {
return false;
@ -279,13 +276,13 @@ static bool IsSupported(const DDSHeader & header)
return true;
}
static bool LoadA8R8G8B8(QDataStream & s, const DDSHeader & header, QImage & img)
static bool LoadA8R8G8B8(QDataStream &s, const DDSHeader &header, QImage &img)
{
const uint w = header.width;
const uint h = header.height;
for (uint y = 0; y < h; y++) {
QRgb * scanline = (QRgb *) img.scanLine(y);
QRgb *scanline = (QRgb *) img.scanLine(y);
for (uint x = 0; x < w; x++) {
uchar r, g, b, a;
s >> b >> g >> r >> a;
@ -296,13 +293,13 @@ static bool LoadA8R8G8B8(QDataStream & s, const DDSHeader & header, QImage & img
return true;
}
static bool LoadR8G8B8(QDataStream & s, const DDSHeader & header, QImage & img)
static bool LoadR8G8B8(QDataStream &s, const DDSHeader &header, QImage &img)
{
const uint w = header.width;
const uint h = header.height;
for (uint y = 0; y < h; y++) {
QRgb * scanline = (QRgb *) img.scanLine(y);
QRgb *scanline = (QRgb *) img.scanLine(y);
for (uint x = 0; x < w; x++) {
uchar r, g, b;
s >> b >> g >> r;
@ -313,13 +310,13 @@ static bool LoadR8G8B8(QDataStream & s, const DDSHeader & header, QImage & img)
return true;
}
static bool LoadA1R5G5B5(QDataStream & s, const DDSHeader & header, QImage & img)
static bool LoadA1R5G5B5(QDataStream &s, const DDSHeader &header, QImage &img)
{
const uint w = header.width;
const uint h = header.height;
for (uint y = 0; y < h; y++) {
QRgb * scanline = (QRgb *) img.scanLine(y);
QRgb *scanline = (QRgb *) img.scanLine(y);
for (uint x = 0; x < w; x++) {
Color1555 color;
s >> color.u;
@ -334,13 +331,13 @@ static bool LoadA1R5G5B5(QDataStream & s, const DDSHeader & header, QImage & img
return true;
}
static bool LoadA4R4G4B4(QDataStream & s, const DDSHeader & header, QImage & img)
static bool LoadA4R4G4B4(QDataStream &s, const DDSHeader &header, QImage &img)
{
const uint w = header.width;
const uint h = header.height;
for (uint y = 0; y < h; y++) {
QRgb * scanline = (QRgb *) img.scanLine(y);
QRgb *scanline = (QRgb *) img.scanLine(y);
for (uint x = 0; x < w; x++) {
Color4444 color;
s >> color.u;
@ -355,13 +352,13 @@ static bool LoadA4R4G4B4(QDataStream & s, const DDSHeader & header, QImage & img
return true;
}
static bool LoadR5G6B5(QDataStream & s, const DDSHeader & header, QImage & img)
static bool LoadR5G6B5(QDataStream &s, const DDSHeader &header, QImage &img)
{
const uint w = header.width;
const uint h = header.height;
for (uint y = 0; y < h; y++) {
QRgb * scanline = (QRgb *) img.scanLine(y);
QRgb *scanline = (QRgb *) img.scanLine(y);
for (uint x = 0; x < w; x++) {
Color565 color;
s >> color.u;
@ -375,18 +372,18 @@ static bool LoadR5G6B5(QDataStream & s, const DDSHeader & header, QImage & img)
return true;
}
static QDataStream & operator>> (QDataStream & s, Color565 & c)
static QDataStream &operator>> (QDataStream &s, Color565 &c)
{
return s >> c.u;
}
struct BlockDXT {
Color565 col0;
Color565 col1;
uchar row[4];
void GetColors(Color8888 color_array[4]) {
void GetColors(Color8888 color_array[4])
{
color_array[0].r = (col0.c.r << 3) | (col0.c.r >> 2);
color_array[0].g = (col0.c.g << 2) | (col0.c.g >> 4);
color_array[0].b = (col0.c.b << 3) | (col0.c.b >> 2);
@ -424,8 +421,7 @@ struct BlockDXT {
}
};
static QDataStream & operator>> (QDataStream & s, BlockDXT & c)
static QDataStream &operator>> (QDataStream &s, BlockDXT &c)
{
return s >> c.col0 >> c.col1 >> c.row[0] >> c.row[1] >> c.row[2] >> c.row[3];
}
@ -434,7 +430,7 @@ struct BlockDXTAlphaExplicit {
ushort row[4];
};
static QDataStream & operator>> (QDataStream & s, BlockDXTAlphaExplicit & c)
static QDataStream &operator>> (QDataStream &s, BlockDXTAlphaExplicit &c)
{
return s >> c.row[0] >> c.row[1] >> c.row[2] >> c.row[3];
}
@ -444,7 +440,8 @@ struct BlockDXTAlphaLinear {
uchar alpha1;
uchar bits[6];
void GetAlphas(uchar alpha_array[8]) {
void GetAlphas(uchar alpha_array[8])
{
alpha_array[0] = alpha0;
alpha_array[1] = alpha1;
@ -472,7 +469,8 @@ struct BlockDXTAlphaLinear {
}
}
void GetBits(uchar bit_array[16]) {
void GetBits(uchar bit_array[16])
{
// Split 24 packed bits into 8 bytes, 3 bits at a time.
uint b = bits[0] | bits[1] << 8 | bits[2] << 16;
bit_array[0] = uchar(b & 0x07); b >>= 3;
@ -496,19 +494,19 @@ struct BlockDXTAlphaLinear {
}
};
static QDataStream & operator>> (QDataStream & s, BlockDXTAlphaLinear & c)
static QDataStream &operator>> (QDataStream &s, BlockDXTAlphaLinear &c)
{
s >> c.alpha0 >> c.alpha1;
return s >> c.bits[0] >> c.bits[1] >> c.bits[2] >> c.bits[3] >> c.bits[4] >> c.bits[5];
}
static bool LoadDXT1(QDataStream & s, const DDSHeader & header, QImage & img)
static bool LoadDXT1(QDataStream &s, const DDSHeader &header, QImage &img)
{
const uint w = header.width;
const uint h = header.height;
BlockDXT block;
QRgb * scanline[4];
QRgb *scanline[4];
for (uint y = 0; y < h; y += 4) {
for (uint j = 0; j < 4; j++) {
@ -541,14 +539,14 @@ static bool LoadDXT1(QDataStream & s, const DDSHeader & header, QImage & img)
return true;
}
static bool LoadDXT3(QDataStream & s, const DDSHeader & header, QImage & img)
static bool LoadDXT3(QDataStream &s, const DDSHeader &header, QImage &img)
{
const uint w = header.width;
const uint h = header.height;
BlockDXT block;
BlockDXTAlphaExplicit alpha;
QRgb * scanline[4];
QRgb *scanline[4];
for (uint y = 0; y < h; y += 4) {
for (uint j = 0; j < 4; j++) {
@ -586,21 +584,23 @@ static bool LoadDXT3(QDataStream & s, const DDSHeader & header, QImage & img)
return true;
}
static bool LoadDXT2(QDataStream & s, const DDSHeader & header, QImage & img)
static bool LoadDXT2(QDataStream &s, const DDSHeader &header, QImage &img)
{
if (!LoadDXT3(s, header, img)) return false;
if (!LoadDXT3(s, header, img)) {
return false;
}
//UndoPremultiplyAlpha(img);
return true;
}
static bool LoadDXT5(QDataStream & s, const DDSHeader & header, QImage & img)
static bool LoadDXT5(QDataStream &s, const DDSHeader &header, QImage &img)
{
const uint w = header.width;
const uint h = header.height;
BlockDXT block;
BlockDXTAlphaLinear alpha;
QRgb * scanline[4];
QRgb *scanline[4];
for (uint y = 0; y < h; y += 4) {
for (uint j = 0; j < 4; j++) {
@ -641,21 +641,23 @@ static bool LoadDXT5(QDataStream & s, const DDSHeader & header, QImage & img)
return true;
}
static bool LoadDXT4(QDataStream & s, const DDSHeader & header, QImage & img)
static bool LoadDXT4(QDataStream &s, const DDSHeader &header, QImage &img)
{
if (!LoadDXT5(s, header, img)) return false;
if (!LoadDXT5(s, header, img)) {
return false;
}
//UndoPremultiplyAlpha(img);
return true;
}
static bool LoadRXGB(QDataStream & s, const DDSHeader & header, QImage & img)
static bool LoadRXGB(QDataStream &s, const DDSHeader &header, QImage &img)
{
const uint w = header.width;
const uint h = header.height;
BlockDXT block;
BlockDXTAlphaLinear alpha;
QRgb * scanline[4];
QRgb *scanline[4];
for (uint y = 0; y < h; y += 4) {
for (uint j = 0; j < 4; j++) {
@ -697,14 +699,14 @@ static bool LoadRXGB(QDataStream & s, const DDSHeader & header, QImage & img)
return true;
}
static bool LoadATI2(QDataStream & s, const DDSHeader & header, QImage & img)
static bool LoadATI2(QDataStream &s, const DDSHeader &header, QImage &img)
{
const uint w = header.width;
const uint h = header.height;
BlockDXTAlphaLinear xblock;
BlockDXTAlphaLinear yblock;
QRgb * scanline[4];
QRgb *scanline[4];
for (uint y = 0; y < h; y += 4) {
for (uint j = 0; j < 4; j++) {
@ -751,9 +753,7 @@ static bool LoadATI2(QDataStream & s, const DDSHeader & header, QImage & img)
return true;
}
typedef bool (* TextureLoader)(QDataStream & s, const DDSHeader & header, QImage & img);
typedef bool (* TextureLoader)(QDataStream &s, const DDSHeader &header, QImage &img);
// Get an appropriate texture loader for the given type.
static TextureLoader GetTextureLoader(DDSType type)
@ -788,9 +788,8 @@ static TextureLoader GetTextureLoader(DDSType type)
};
}
// Load a 2d texture.
static bool LoadTexture(QDataStream & s, const DDSHeader & header, QImage & img)
static bool LoadTexture(QDataStream &s, const DDSHeader &header, QImage &img)
{
// Create dst image.
img = QImage(header.width, header.height, QImage::Format_RGB32);
@ -811,8 +810,7 @@ static bool LoadTexture(QDataStream & s, const DDSHeader & header, QImage & img)
return loader(s, header, img);
}
static int FaceOffset(const DDSHeader & header)
static int FaceOffset(const DDSHeader &header)
{
DDSType type = GetType(header);
@ -858,7 +856,7 @@ static int face_flags[6] = {
};
// Load unwrapped cube map.
static bool LoadCubeMap(QDataStream & s, const DDSHeader & header, QImage & img)
static bool LoadCubeMap(QDataStream &s, const DDSHeader &header, QImage &img)
{
// Create dst image.
#if CUBE_LAYOUT == HORIZONTAL
@ -917,8 +915,8 @@ static bool LoadCubeMap(QDataStream & s, const DDSHeader & header, QImage & img)
// Copy face on the image.
for (uint y = 0; y < header.height; y++) {
QRgb * src = (QRgb *) face.scanLine(y);
QRgb * dst = (QRgb *) img.scanLine(y + offset_y) + offset_x;
QRgb *src = (QRgb *) face.scanLine(y);
QRgb *dst = (QRgb *) img.scanLine(y + offset_y) + offset_x;
memcpy(dst, src, sizeof(QRgb) * header.width);
}
}
@ -926,8 +924,6 @@ static bool LoadCubeMap(QDataStream & s, const DDSHeader & header, QImage & img)
return true;
}
DDSHandler::DDSHandler()
{
}
@ -994,8 +990,9 @@ bool DDSHandler::canRead(QIODevice *device)
qint64 readBytes = device->read(head, sizeof(head));
if (readBytes != sizeof(head)) {
if (device->isSequential()) {
while (readBytes > 0)
while (readBytes > 0) {
device->ungetChar(head[readBytes-- - 1]);
}
} else {
device->seek(oldPos);
}
@ -1003,8 +1000,9 @@ bool DDSHandler::canRead(QIODevice *device)
}
if (device->isSequential()) {
while (readBytes > 0)
while (readBytes > 0) {
device->ungetChar(head[readBytes-- - 1]);
}
} else {
device->seek(oldPos);
}
@ -1014,16 +1012,20 @@ bool DDSHandler::canRead(QIODevice *device)
QImageIOPlugin::Capabilities DDSPlugin::capabilities(QIODevice *device, const QByteArray &format) const
{
if (format == "dds")
if (format == "dds") {
return Capabilities(CanRead);
if (!format.isEmpty())
}
if (!format.isEmpty()) {
return 0;
if (!device->isOpen())
}
if (!device->isOpen()) {
return 0;
}
Capabilities cap;
if (device->isReadable() && DDSHandler::canRead(device))
if (device->isReadable() && DDSHandler::canRead(device)) {
cap |= CanRead;
}
return cap;
}

40
src/imageformats/eps.cpp
View File

@ -49,7 +49,7 @@ static bool seekToCodeStart(QIODevice *io, qint64 &ps_offset, qint64 &ps_size)
return false;
}
ps_offset // Offset is in little endian
= qint64( ((unsigned char)buf[0])
= qint64(((unsigned char)buf[0])
+ ((unsigned char)buf[1] << 8)
+ ((unsigned char)buf[2] << 16)
+ ((unsigned char)buf[3] << 24));
@ -58,11 +58,11 @@ static bool seekToCodeStart(QIODevice *io, qint64 &ps_offset, qint64 &ps_size)
return false;
}
ps_size // Size is in little endian
= qint64( ((unsigned char)buf[0])
= qint64(((unsigned char)buf[0])
+ ((unsigned char)buf[1] << 8)
+ ((unsigned char)buf[2] << 16)
+ ((unsigned char)buf[3] << 24));
qCDebug(EPSPLUGIN) << "Offset: " << ps_offset <<" Size: " << ps_size;
qCDebug(EPSPLUGIN) << "Offset: " << ps_offset << " Size: " << ps_size;
if (!io->seek(ps_offset)) { // Get offset of PostScript code in the MS-DOS EPS file.
qCDebug(EPSPLUGIN) << "cannot seek in MS-DOS EPS file";
return false;
@ -138,12 +138,13 @@ bool EPSHandler::read(QImage *image)
dt.start();
#endif
QIODevice* io = device();
QIODevice *io = device();
qint64 ps_offset, ps_size;
// find start of PostScript code
if (!seekToCodeStart(io, ps_offset, ps_size))
if (!seekToCodeStart(io, ps_offset, ps_size)) {
return false;
}
qCDebug(EPSPLUGIN) << "Offset:" << ps_offset << "; size:" << ps_size;
@ -202,15 +203,16 @@ bool EPSHandler::read(QImage *image)
}
QByteArray intro = "\n";
intro += QByteArray::number(-qRound(x1*xScale));
intro += QByteArray::number(-qRound(x1 * xScale));
intro += " ";
intro += QByteArray::number(-qRound(y1*yScale));
intro += QByteArray::number(-qRound(y1 * yScale));
intro += " translate\n";
converter.write(intro);
io->reset();
if (ps_offset > 0)
if (ps_offset > 0) {
io->seek(ps_offset);
}
QByteArray buffer;
buffer.resize(4096);
@ -246,15 +248,15 @@ bool EPSHandler::read(QImage *image)
}
}
bool EPSHandler::write(const QImage &image)
{
QPrinter psOut(QPrinter::PrinterResolution);
QPainter p;
QTemporaryFile tmpFile(QStringLiteral("XXXXXXXX.pdf"));
if (!tmpFile.open())
if (!tmpFile.open()) {
return false;
}
psOut.setCreator(QStringLiteral("KDE EPS image plugin"));
psOut.setOutputFileName(tmpFile.fileName());
@ -319,8 +321,9 @@ bool EPSHandler::canRead(QIODevice *device)
QByteArray head = device->readLine(64);
int readBytes = head.size();
if (device->isSequential()) {
while (readBytes > 0)
while (readBytes > 0) {
device->ungetChar(head[readBytes-- - 1]);
}
} else {
device->seek(oldPos);
}
@ -330,18 +333,23 @@ bool EPSHandler::canRead(QIODevice *device)
QImageIOPlugin::Capabilities EPSPlugin::capabilities(QIODevice *device, const QByteArray &format) const
{
if (format == "eps" || format == "epsi" || format == "epsf")
if (format == "eps" || format == "epsi" || format == "epsf") {
return Capabilities(CanRead | CanWrite);
if (!format.isEmpty())
}
if (!format.isEmpty()) {
return 0;
if (!device->isOpen())
}
if (!device->isOpen()) {
return 0;
}
Capabilities cap;
if (device->isReadable() && EPSHandler::canRead(device))
if (device->isReadable() && EPSHandler::canRead(device)) {
cap |= CanRead;
if (device->isWritable())
}
if (device->isWritable()) {
cap |= CanWrite;
}
return cap;
}

38
src/imageformats/exr.cpp
View File

@ -1,4 +1,3 @@
// -*- C++;indent-tabs-mode: t; tab-width: 4; c-basic-offset: 4; -*-
/**
* KImageIO Routines to read (and perhaps in the future, write) images
@ -37,8 +36,9 @@
class K_IStream: public Imf::IStream
{
public:
K_IStream(QIODevice *dev, const QByteArray& fileName):
IStream(fileName.data()), m_dev(dev) {
K_IStream(QIODevice *dev, const QByteArray &fileName):
IStream(fileName.data()), m_dev(dev)
{
}
virtual bool read(char c[], int n);
@ -57,8 +57,9 @@ bool K_IStream::read(char c[], int n)
return true;
} else if (result == 0) {
throw Iex::InputExc("Unexpected end of file");
} else // negative value {
} else { // negative value {
Iex::throwErrnoExc("Error in read", result);
}
return false;
}
@ -115,14 +116,18 @@ QRgb RgbaToQrgba(struct Imf::Rgba imagePixel)
// this value will be mapped to the display's
// maximum intensity).
// Response: kneeLow = 0.0 (2^0.0 => 1); kneeHigh = 5.0 (2^5 =>32)
if (r > 1.0)
if (r > 1.0) {
r = 1.0 + Imath::Math<float>::log((r - 1.0) * 0.184874 + 1) / 0.184874;
if (g > 1.0)
}
if (g > 1.0) {
g = 1.0 + Imath::Math<float>::log((g - 1.0) * 0.184874 + 1) / 0.184874;
if (b > 1.0)
}
if (b > 1.0) {
b = 1.0 + Imath::Math<float>::log((b - 1.0) * 0.184874 + 1) / 0.184874;
if (a > 1.0)
}
if (a > 1.0) {
a = 1.0 + Imath::Math<float>::log((a - 1.0) * 0.184874 + 1) / 0.184874;
}
//
// 5) Gamma-correct the pixel values, assuming that the
// screen's gamma is 0.4545 (or 1/2.2).
@ -174,8 +179,9 @@ bool EXRHandler::read(QImage *outImage)
file.readPixels(dw.min.y, dw.max.y);
QImage image(width, height, QImage::Format_RGB32);
if (image.isNull())
if (image.isNull()) {
return false;
}
// somehow copy pixels into image
for (int y = 0; y < height; y++) {
@ -194,7 +200,6 @@ bool EXRHandler::read(QImage *outImage)
}
}
bool EXRHandler::write(const QImage &image)
{
// TODO: stub
@ -202,7 +207,6 @@ bool EXRHandler::write(const QImage &image)
return false;
}
bool EXRHandler::canRead(QIODevice *device)
{
if (!device) {
@ -217,16 +221,20 @@ bool EXRHandler::canRead(QIODevice *device)
QImageIOPlugin::Capabilities EXRPlugin::capabilities(QIODevice *device, const QByteArray &format) const
{
if (format == "exr")
if (format == "exr") {
return Capabilities(CanRead);
if (!format.isEmpty())
}
if (!format.isEmpty()) {
return 0;
if (!device->isOpen())
}
if (!device->isOpen()) {
return 0;
}
Capabilities cap;
if (device->isReadable() && EXRHandler::canRead(device))
if (device->isReadable() && EXRHandler::canRead(device)) {
cap |= CanRead;
}
return cap;
}

66
src/imageformats/gimp.h
View File

@ -178,7 +178,7 @@ inline int INT_BLEND(int a, int b, int alpha)
* \param green the green component (modified in place).
* \param blue the blue component (modified in place).
*/
static void RGBTOHSV(uchar& red, uchar& green, uchar& blue)
static void RGBTOHSV(uchar &red, uchar &green, uchar &blue)
{
int r, g, b;
double h, s, v;
@ -200,27 +200,31 @@ static void RGBTOHSV(uchar& red, uchar& green, uchar& blue)
v = max;
if (max != 0)
if (max != 0) {
s = ((max - min) * 255) / (double)max;
else
} else {
s = 0;
}
if (s == 0)
if (s == 0) {
h = 0;
else {
} else {
int delta = max - min;
if (r == max)
if (r == max) {
h = (g - b) / (double)delta;
else if (g == max)
} else if (g == max) {
h = 2 + (b - r) / (double)delta;
else if (b == max)
} else if (b == max) {
h = 4 + (r - g) / (double)delta;
}
h *= 42.5;
if (h < 0)
if (h < 0) {
h += 255;
if (h > 255)
}
if (h > 255) {
h -= 255;
}
}
red = (uchar)h;
@ -234,7 +238,7 @@ static void RGBTOHSV(uchar& red, uchar& green, uchar& blue)
* \param saturation the saturation component (modified in place).
* \param value the value component (modified in place).
*/
static void HSVTORGB(uchar& hue, uchar& saturation, uchar& value)
static void HSVTORGB(uchar &hue, uchar &saturation, uchar &value)
{
if (saturation == 0) {
hue = value;
@ -293,7 +297,7 @@ static void HSVTORGB(uchar& hue, uchar& saturation, uchar& value)
* \param green the green component (modified in place).
* \param blue the blue component (modified in place).
*/
static void RGBTOHLS(uchar& red, uchar& green, uchar& blue)
static void RGBTOHLS(uchar &red, uchar &green, uchar &blue)
{
int r = red;
int g = green;
@ -319,24 +323,27 @@ static void RGBTOHLS(uchar& red, uchar& green, uchar& blue)
} else {
int delta = max - min;
if (l < 128)
if (l < 128) {
s = 255 * (double)delta / (double)(max + min);
else
} else {
s = 255 * (double)delta / (double)(511 - max - min);
}
if (r == max)
if (r == max) {
h = (g - b) / (double)delta;
else if (g == max)
} else if (g == max) {
h = 2 + (b - r) / (double)delta;
else
} else {
h = 4 + (r - g) / (double)delta;
}
h *= 42.5;
if (h < 0)
if (h < 0) {
h += 255;
else if (h > 255)
} else if (h > 255) {
h -= 255;
}
}
red = (uchar)h;
@ -355,19 +362,21 @@ static int HLSVALUE(double n1, double n2, double hue)
{
double value;
if (hue > 255)
if (hue > 255) {
hue -= 255;
else if (hue < 0)
} else if (hue < 0) {
hue += 255;
}
if (hue < 42.5)
if (hue < 42.5) {
value = n1 + (n2 - n1) * (hue / 42.5);
else if (hue < 127.5)
} else if (hue < 127.5) {
value = n2;
else if (hue < 170)
} else if (hue < 170) {
value = n1 + (n2 - n1) * ((170 - hue) / 42.5);
else
} else {
value = n1;
}
return (int)(value * 255);
}
@ -378,7 +387,7 @@ static int HLSVALUE(double n1, double n2, double hue)
* \param lightness the lightness component (modified in place).
* \param saturation the saturation component (modified in place).
*/
static void HLSTORGB(uchar& hue, uchar& lightness, uchar& saturation)
static void HLSTORGB(uchar &hue, uchar &lightness, uchar &saturation)
{
double h = hue;
double l = lightness;
@ -391,10 +400,11 @@ static void HLSTORGB(uchar& hue, uchar& lightness, uchar& saturation)
} else {
double m1, m2;
if (l < 128)
if (l < 128) {
m2 = (l * (255 + s)) / 65025.;
else
} else {
m2 = (l + s - (l * s) / 255.) / 255.;
}
m1 = (l / 127.5) - m2;

21
src/imageformats/hdr.cpp
View File

@ -26,14 +26,16 @@ namespace // Private.
static inline uchar ClipToByte(float value)
{
if (value > 255.0f) return 255;
if (value > 255.0f) {
return 255;
}
//else if (value < 0.0f) return 0; // we know value is positive.
return uchar(value);
}
// read an old style line from the hdr image file
// if 'first' is true the first byte is already read
static bool Read_Old_Line(uchar * image, int width, QDataStream & s)
static bool Read_Old_Line(uchar *image, int width, QDataStream &s)
{
int rshift = 0;
int i;
@ -44,7 +46,9 @@ static bool Read_Old_Line(uchar * image, int width, QDataStream & s)
s >> image[2];
s >> image[3];
if (s.atEnd()) return false;
if (s.atEnd()) {
return false;
}
if ((image[0] == 1) && (image[1] == 1) && (image[2] == 1)) {
for (i = image[3] << rshift; i > 0; i--) {
@ -63,8 +67,7 @@ static bool Read_Old_Line(uchar * image, int width, QDataStream & s)
return true;
}
static void RGBE_To_QRgbLine(uchar * image, QRgb * scanline, int width)
static void RGBE_To_QRgbLine(uchar *image, QRgb *scanline, int width)
{
for (int j = 0; j < width; j++) {
// v = ldexp(1.0, int(image[3]) - 128);
@ -85,7 +88,7 @@ static void RGBE_To_QRgbLine(uchar * image, QRgb * scanline, int width)
}
// Load the HDR image.
static bool LoadHDR(QDataStream & s, const int width, const int height, QImage & img)
static bool LoadHDR(QDataStream &s, const int width, const int height, QImage &img)
{
uchar val, code;
@ -97,7 +100,7 @@ static bool LoadHDR(QDataStream & s, const int width, const int height, QImage &
QMemArray<uchar> image(width * 4);
for (int cline = 0; cline < height; cline++) {
QRgb * scanline = (QRgb *) img.scanLine(cline);
QRgb *scanline = (QRgb *) img.scanLine(cline);
// determine scanline type
if ((width < MINELEN) || (MAXELEN < width)) {
@ -173,8 +176,7 @@ static bool LoadHDR(QDataStream & s, const int width, const int height, QImage &
} // namespace
Q_DECL_EXPORT void kimgio_hdr_read(QImageIO * io)
Q_DECL_EXPORT void kimgio_hdr_read(QImageIO *io)
{
int len;
char line[MAXLINE];
@ -229,7 +231,6 @@ Q_DECL_EXPORT void kimgio_hdr_read(QImageIO * io)
io->setStatus(0);
}
Q_DECL_EXPORT void kimgio_hdr_write(QImageIO *)
{
// intentionally not implemented (since writing low dynamic range data to a HDR file is nonsense.)

149
src/imageformats/jp2.cpp
View File

@ -31,7 +31,6 @@
#define DEFAULT_RATE 0.10
#define MAXCMPTS 256
/************************* JasPer QIODevice stream ***********************/
//unfortunately this is declared as static in JasPer libraries
@ -39,7 +38,7 @@ static jas_stream_t *jas_stream_create()
{
jas_stream_t *stream;
if (!(stream = (jas_stream_t*)jas_malloc(sizeof(jas_stream_t)))) {
if (!(stream = (jas_stream_t *)jas_malloc(sizeof(jas_stream_t)))) {
return 0;
}
stream->openmode_ = 0;
@ -71,7 +70,7 @@ static void jas_stream_initbuf(jas_stream_t *stream, int bufmode, char *buf,
if (!buf) {
/* The caller has not specified a buffer to employ, so allocate
one. */
if ((stream->bufbase_ = (unsigned char*)jas_malloc(JAS_STREAM_BUFSIZE +
if ((stream->bufbase_ = (unsigned char *)jas_malloc(JAS_STREAM_BUFSIZE +
JAS_STREAM_MAXPUTBACK))) {
stream->bufmode_ |= JAS_STREAM_FREEBUF;
stream->bufsize_ = JAS_STREAM_BUFSIZE;
@ -105,19 +104,19 @@ static void jas_stream_initbuf(jas_stream_t *stream, int bufmode, char *buf,
static int qiodevice_read(jas_stream_obj_t *obj, char *buf, int cnt)
{
QIODevice *io = (QIODevice*) obj;
QIODevice *io = (QIODevice *) obj;
return io->read(buf, cnt);
}
static int qiodevice_write(jas_stream_obj_t *obj, char *buf, int cnt)
{
QIODevice *io = (QIODevice*) obj;
QIODevice *io = (QIODevice *) obj;
return io->write(buf, cnt);
}
static long qiodevice_seek(jas_stream_obj_t *obj, long offset, int origin)
{
QIODevice *io = (QIODevice*) obj;
QIODevice *io = (QIODevice *) obj;
long newpos;
switch (origin) {
@ -136,10 +135,11 @@ static long qiodevice_seek(jas_stream_obj_t *obj, long offset, int origin)
if (newpos < 0) {
return -1;
}
if (io->seek(newpos))
if (io->seek(newpos)) {
return newpos;
else
} else {
return -1;
}
}
static int qiodevice_close(jas_stream_obj_t *)
@ -158,7 +158,9 @@ static jas_stream_t *jas_stream_qiodevice(QIODevice *iodevice)
{
jas_stream_t *stream;
if (!iodevice) return 0;
if (!iodevice) {
return 0;
}
if (!(stream = jas_stream_create())) {
return 0;
}
@ -179,24 +181,25 @@ static jas_stream_t *jas_stream_qiodevice(QIODevice *iodevice)
/************************ End of JasPer QIODevice stream ****************/
typedef struct {
jas_image_t* image;
jas_image_t *image;
int cmptlut[MAXCMPTS];
jas_image_t* altimage;
jas_image_t *altimage;
} gs_t;
static jas_image_t*
read_image(QIODevice* io)
static jas_image_t *
read_image(QIODevice *io)
{
jas_stream_t* in = 0;
jas_stream_t *in = 0;
in = jas_stream_qiodevice(io);
if (!in) return 0;
if (!in) {
return 0;
}
jas_image_t* image = jas_image_decode(in, -1, 0);
jas_image_t *image = jas_image_decode(in, -1, 0);
jas_stream_close(in);
// image may be 0, but that's Ok
@ -204,22 +207,28 @@ read_image(QIODevice* io)
} // read_image
static bool
convert_colorspace(gs_t& gs)
convert_colorspace(gs_t &gs)
{
jas_cmprof_t *outprof = jas_cmprof_createfromclrspc(JAS_CLRSPC_SRGB);
if (!outprof) return false;
if (!outprof) {
return false;
}
gs.altimage = jas_image_chclrspc(gs.image, outprof,
JAS_CMXFORM_INTENT_PER);
if (!gs.altimage) return false;
if (!gs.altimage) {
return false;
}
return true;
} // convert_colorspace
static bool
render_view(gs_t& gs, QImage* outImage)
render_view(gs_t &gs, QImage *outImage)
{
if (!gs.altimage) return false;
if (!gs.altimage) {
return false;
}
QImage qti;
if ((gs.cmptlut[0] = jas_image_getcmptbytype(gs.altimage,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R))) < 0 ||
@ -230,7 +239,7 @@ render_view(gs_t& gs, QImage* outImage)
return false;
} // if
const int* cmptlut = gs.cmptlut;
const int *cmptlut = gs.cmptlut;
int v[3];
// check that all components have the same size.
@ -238,8 +247,9 @@ render_view(gs_t& gs, QImage* outImage)
const int height = jas_image_cmptheight(gs.altimage, cmptlut[0]);
for (int i = 1; i < 3; ++i) {
if (jas_image_cmptwidth(gs.altimage, cmptlut[i]) != width ||
jas_image_cmptheight(gs.altimage, cmptlut[i]) != height)
jas_image_cmptheight(gs.altimage, cmptlut[i]) != height) {
return false;
}
} // for
jas_matrix_t *cmptmatrix[3];
@ -258,7 +268,7 @@ render_view(gs_t& gs, QImage* outImage)
if (qti.isNull()) {
return false;
}
uint32_t* data = (uint32_t*)qti.bits();
uint32_t *data = (uint32_t *)qti.bits();
for (int y = 0; y < height; ++y) {
for (int k = 0; k < 3; ++k) {
@ -274,8 +284,11 @@ render_view(gs_t& gs, QImage* outImage)
// it to use the complete value range.
v[k] <<= 8 - prec[k];
if (v[k] < 0) v[k] = 0;
else if (v[k] > 255) v[k] = 255;
if (v[k] < 0) {
v[k] = 0;
} else if (v[k] > 255) {
v[k] = 255;
}
++buf[k];
} // for k
@ -293,12 +306,11 @@ render_view(gs_t& gs, QImage* outImage)
return true;
} // render_view
static jas_image_t*
create_image(const QImage& qi)
static jas_image_t *
create_image(const QImage &qi)
{
// prepare the component parameters
jas_image_cmptparm_t* cmptparms = new jas_image_cmptparm_t[ 3 ];
jas_image_cmptparm_t *cmptparms = new jas_image_cmptparm_t[ 3 ];
for (int i = 0; i < 3; ++i) {
// x and y offset
@ -316,41 +328,45 @@ create_image(const QImage& qi)
cmptparms[i].sgnd = false;
}
jas_image_t* ji = jas_image_create(3 /* number components */, cmptparms, JAS_CLRSPC_UNKNOWN);
jas_image_t *ji = jas_image_create(3 /* number components */, cmptparms, JAS_CLRSPC_UNKNOWN);
delete[] cmptparms;
// returning 0 is ok
return ji;
} // create_image
static bool
write_components(jas_image_t* ji, const QImage& qi)
write_components(jas_image_t *ji, const QImage &qi)
{
const unsigned height = qi.height();
const unsigned width = qi.width();
jas_matrix_t* m = jas_matrix_create(height, width);
if (!m) return false;
jas_matrix_t *m = jas_matrix_create(height, width);
if (!m) {
return false;
}
jas_image_setclrspc(ji, JAS_CLRSPC_SRGB);
jas_image_setcmpttype(ji, 0, JAS_IMAGE_CT_RGB_R);
for (uint y = 0; y < height; ++y)
for (uint x = 0; x < width; ++x)
for (uint x = 0; x < width; ++x) {
jas_matrix_set(m, y, x, qRed(qi.pixel(x, y)));
}
jas_image_writecmpt(ji, 0, 0, 0, width, height, m);
jas_image_setcmpttype(ji, 1, JAS_IMAGE_CT_RGB_G);
for (uint y = 0; y < height; ++y)
for (uint x = 0; x < width; ++x)
for (uint x = 0; x < width; ++x) {
jas_matrix_set(m, y, x, qGreen(qi.pixel(x, y)));
}
jas_image_writecmpt(ji, 1, 0, 0, width, height, m);
jas_image_setcmpttype(ji, 2, JAS_IMAGE_CT_RGB_B);
for (uint y = 0; y < height; ++y)
for (uint x = 0; x < width; ++x)
for (uint x = 0; x < width; ++x) {
jas_matrix_set(m, y, x, qBlue(qi.pixel(x, y)));
}
jas_image_writecmpt(ji, 2, 0, 0, width, height, m);
jas_matrix_destroy(m);
@ -358,15 +374,17 @@ write_components(jas_image_t* ji, const QImage& qi)
} // write_components
static bool
write_image(const QImage &image, QIODevice* io, int quality)
write_image(const QImage &image, QIODevice *io, int quality)
{
jas_stream_t* stream = 0;
jas_stream_t *stream = 0;
stream = jas_stream_qiodevice(io);
// by here, a jas_stream_t is open
if (!stream) return false;
if (!stream) {
return false;
}
jas_image_t* ji = create_image(image);
jas_image_t *ji = create_image(image);
if (!ji) {
jas_stream_close(stream);
return false;
@ -390,7 +408,9 @@ write_image(const QImage &image, QIODevice* io, int quality)
jas_image_destroy(ji);
jas_stream_close(stream);
if (i != 0) return false;
if (i != 0) {
return false;
}
return true;
}
@ -425,17 +445,27 @@ bool JP2Handler::canRead(QIODevice *device)
bool JP2Handler::read(QImage *image)
{
if (!canRead()) return false;
if (!canRead()) {
return false;
}
gs_t gs;
if (!(gs.image = read_image(device()))) return false;
if (!(gs.image = read_image(device()))) {
return false;
}
if (!convert_colorspace(gs)) return false;
if (!convert_colorspace(gs)) {
return false;
}
render_view(gs, image);
if (gs.image) jas_image_destroy(gs.image);
if (gs.altimage) jas_image_destroy(gs.altimage);
if (gs.image) {
jas_image_destroy(gs.image);
}
if (gs.altimage) {
jas_image_destroy(gs.altimage);
}
return true;
}
@ -452,31 +482,38 @@ bool JP2Handler::supportsOption(ImageOption option) const
QVariant JP2Handler::option(ImageOption option) const
{
if (option == Quality)
if (option == Quality) {
return quality;
}
return QVariant();
}
void JP2Handler::setOption(ImageOption option, const QVariant &value)
{
if (option == Quality)
if (option == Quality) {
quality = qBound(-1, value.toInt(), 100);
}
}
QImageIOPlugin::Capabilities JP2Plugin::capabilities(QIODevice *device, const QByteArray &format) const
{
if (format == "jp2")
if (format == "jp2") {
return Capabilities(CanRead | CanWrite);
if (!format.isEmpty())
}
if (!format.isEmpty()) {
return 0;
if (!device->isOpen())
}
if (!device->isOpen()) {
return 0;
}
Capabilities cap;
if (device->isReadable() && JP2Handler::canRead(device))
if (device->isReadable() && JP2Handler::canRead(device)) {
cap |= CanRead;
if (device->isWritable())
}
if (device->isWritable()) {
cap |= CanWrite;
}
return cap;
}

97
src/imageformats/pcx.cpp
View File

@ -21,7 +21,8 @@ public:
quint8 g;
quint8 b;
static RGB from(const QRgb &color) {
static RGB from(const QRgb &color)
{
RGB c;
c.r = qRed(color);
c.g = qGreen(color);
@ -34,14 +35,16 @@ public:
class Palette
{
public:
void setColor(int i, const QRgb color) {
void setColor(int i, const QRgb color)
{
RGB &c = rgb[ i ];
c.r = qRed(color);
c.g = qGreen(color);
c.b = qBlue(color);
}
QRgb color(int i) const {
QRgb color(int i) const
{
return qRgb(rgb[ i ].r, rgb[ i ].g, rgb[ i ].b);
}
@ -53,13 +56,16 @@ class PCXHEADER
public:
PCXHEADER();
inline int width() const {
inline int width() const
{
return (XMax - XMin) + 1;
}
inline int height() const {
inline int height() const
{
return (YMax - YMin) + 1;
}
inline bool isCompressed() const {
inline bool isCompressed() const
{
return (Encoding == 1);
}
@ -111,8 +117,9 @@ static QDataStream &operator>>(QDataStream &s, RGB &rgb)
static QDataStream &operator>>(QDataStream &s, Palette &pal)
{
for (int i = 0; i < 16; ++i)
for (int i = 0; i < 16; ++i) {
s >> pal.rgb[ i ];
}
return s;
}
@ -151,8 +158,9 @@ static QDataStream &operator>>(QDataStream &s, PCXHEADER &ph)
// Skip the rest of the header
quint8 byte;
while (s.device()->pos() < 128)
while (s.device()->pos() < 128) {
s >> byte;
}
return s;
}
@ -166,8 +174,9 @@ static QDataStream &operator<<(QDataStream &s, const RGB &rgb)
static QDataStream &operator<<(QDataStream &s, const Palette &pal)
{
for (int i = 0; i < 16; ++i)
for (int i = 0; i < 16; ++i) {
s << pal.rgb[ i ];
}
return s;
}
@ -189,8 +198,9 @@ static QDataStream &operator<<(QDataStream &s, const PCXHEADER &ph)
s << ph.VScreenSize;
quint8 byte = 0;
for (int i = 0; i < 54; ++i)
for (int i = 0; i < 54; ++i) {
s << byte;
}
return s;
}
@ -219,8 +229,9 @@ static void readLine(QDataStream &s, QByteArray &buf, const PCXHEADER &header)
count = byte - 0xc0;
s >> byte;
}
while (count-- && i < size)
while (count-- && i < size) {
buf[ i++ ] = byte;
}
}
} else {
// Image is not compressed (possible?)
@ -247,8 +258,9 @@ static void readImage1(QImage &img, QDataStream &s, const PCXHEADER &header)
readLine(s, buf, header);
uchar *p = img.scanLine(y);
unsigned int bpl = qMin((quint16)((header.width() + 7) / 8), header.BytesPerLine);
for (unsigned int x = 0; x < bpl; ++x)
for (unsigned int x = 0; x < bpl; ++x) {
p[ x ] = buf[x];
}
}
// Set the color palette
@ -276,18 +288,21 @@ static void readImage4(QImage &img, QDataStream &s, const PCXHEADER &header)
for (int i = 0; i < 4; i++) {
quint32 offset = i * header.BytesPerLine;
for (int x = 0; x < header.width(); ++x)
if (buf[ offset + (x / 8) ] & (128 >> (x % 8)))
if (buf[ offset + (x / 8) ] & (128 >> (x % 8))) {
pixbuf[ x ] = (int)(pixbuf[ x ]) + (1 << i);
}
}
uchar *p = img.scanLine(y);
for (int x = 0; x < header.width(); ++x)
for (int x = 0; x < header.width(); ++x) {
p[ x ] = pixbuf[ x ];
}
}
// Read the palette
for (int i = 0; i < 16; ++i)
for (int i = 0; i < 16; ++i) {
img.setColor(i, header.ColorMap.color(i));
}
}
static void readImage8(QImage &img, QDataStream &s, const PCXHEADER &header)
@ -307,8 +322,9 @@ static void readImage8(QImage &img, QDataStream &s, const PCXHEADER &header)
uchar *p = img.scanLine(y);
unsigned int bpl = qMin(header.BytesPerLine, (quint16)header.width());
for (unsigned int x = 0; x < bpl; ++x)
for (unsigned int x = 0; x < bpl; ++x) {
p[ x ] = buf[ x ];
}
}
quint8 flag;
@ -344,8 +360,9 @@ static void readImage24(QImage &img, QDataStream &s, const PCXHEADER &header)
readLine(s, b_buf, header);
uint *p = (uint *)img.scanLine(y);
for (int x = 0; x < header.width(); ++x)
for (int x = 0; x < header.width(); ++x) {
p[ x ] = qRgb(r_buf[ x ], g_buf[ x ], b_buf[ x ]);
}
}
}
@ -392,8 +409,9 @@ static void writeImage1(QImage &img, QDataStream &s, PCXHEADER &header)
quint8 *p = img.scanLine(y);
// Invert as QImage uses reverse palette for monochrome images?
for (int i = 0; i < header.BytesPerLine; ++i)
for (int i = 0; i < header.BytesPerLine; ++i) {
buf[ i ] = ~p[ i ];
}
writeLine(s, buf);
}
@ -405,30 +423,35 @@ static void writeImage4(QImage &img, QDataStream &s, PCXHEADER &header)
header.NPlanes = 4;
header.BytesPerLine = header.width() / 8;
for (int i = 0; i < 16; ++i)
for (int i = 0; i < 16; ++i) {
header.ColorMap.setColor(i, img.color(i));
}
s << header;
QByteArray buf[ 4 ];
for (int i = 0; i < 4; ++i)
for (int i = 0; i < 4; ++i) {
buf[ i ].resize(header.BytesPerLine);
}
for (int y = 0; y < header.height(); ++y) {
quint8 *p = img.scanLine(y);
for (int i = 0; i < 4; ++i)
for (int i = 0; i < 4; ++i) {
buf[ i ].fill(0);
}
for (int x = 0; x < header.width(); ++x) {
for (int i = 0; i < 4; ++i)
if (*(p + x) & (1 << i))
if (*(p + x) & (1 << i)) {
buf[ i ][ x / 8 ] = (int)(buf[ i ][ x / 8 ]) | 1 << (7 - x % 8);
}
}
for (int i = 0; i < 4; ++i)
for (int i = 0; i < 4; ++i) {
writeLine(s, buf[ i ]);
}
}
}
@ -445,8 +468,9 @@ static void writeImage8(QImage &img, QDataStream &s, PCXHEADER &header)
for (int y = 0; y < header.height(); ++y) {
quint8 *p = img.scanLine(y);
for (int i = 0; i < header.BytesPerLine; ++i)
for (int i = 0; i < header.BytesPerLine; ++i) {
buf[ i ] = p[ i ];
}
writeLine(s, buf);
}
@ -456,8 +480,9 @@ static void writeImage8(QImage &img, QDataStream &s, PCXHEADER &header)
s << byte;
// Write palette
for (int i = 0; i < 256; ++i)
for (int i = 0; i < 256; ++i) {
s << RGB::from(img.color(i));
}
}
static void writeImage24(QImage &img, QDataStream &s, PCXHEADER &header)
@ -488,7 +513,6 @@ static void writeImage24(QImage &img, QDataStream &s, PCXHEADER &header)
}
}
PCXHandler::PCXHandler()
{
}
@ -613,8 +637,9 @@ bool PCXHandler::canRead(QIODevice *device)
qint64 readBytes = device->read(head, sizeof(head));
if (readBytes != sizeof(head)) {
if (device->isSequential()) {
while (readBytes > 0)
while (readBytes > 0) {
device->ungetChar(head[readBytes-- - 1]);
}
} else {
device->seek(oldPos);
}
@ -622,8 +647,9 @@ bool PCXHandler::canRead(QIODevice *device)
}
if (device->isSequential()) {
while (readBytes > 0)
while (readBytes > 0) {
device->ungetChar(head[readBytes-- - 1]);
}
} else {
device->seek(oldPos);
}
@ -633,18 +659,23 @@ bool PCXHandler::canRead(QIODevice *device)
QImageIOPlugin::Capabilities PCXPlugin::capabilities(QIODevice *device, const QByteArray &format) const
{
if (format == "pcx")
if (format == "pcx") {
return Capabilities(CanRead | CanWrite);
if (!format.isEmpty())
}
if (!format.isEmpty()) {
return 0;
if (!device->isOpen())
}
if (!device->isOpen()) {
return 0;
}
Capabilities cap;
if (device->isReadable() && PCXHandler::canRead(device))
if (device->isReadable() && PCXHandler::canRead(device)) {
cap |= CanRead;
if (device->isWritable())
}
if (device->isWritable()) {
cap |= CanWrite;
}
return cap;
}

13
src/imageformats/pic.cpp
View File

@ -77,12 +77,15 @@ bool SoftimagePICHandler::supportsOption(ImageOption option) const
QImageIOPlugin::Capabilities SoftimagePICPlugin::capabilities(QIODevice *device, const QByteArray &format) const
{
if (format == "pic")
if (format == "pic") {
return Capabilities(CanRead | CanWrite);
if (!format.isEmpty())
}
if (!format.isEmpty()) {
return 0;
if (!device->isOpen())
}
if (!device->isOpen()) {
return 0;
}
Capabilities cap;
if (device->isReadable() && SoftimagePICHandler::canRead(device)) {
@ -94,9 +97,9 @@ QImageIOPlugin::Capabilities SoftimagePICPlugin::capabilities(QIODevice *device,
return cap;
}
QImageIOHandler * SoftimagePICPlugin::create(QIODevice *device, const QByteArray &format) const
QImageIOHandler *SoftimagePICPlugin::create(QIODevice *device, const QByteArray &format) const
{
QImageIOHandler * handler = new SoftimagePICHandler();
QImageIOHandler *handler = new SoftimagePICHandler();
handler->setDevice(device);
handler->setFormat(format);
return handler;

2
src/imageformats/pic.h
View File

@ -27,7 +27,7 @@ class SoftimagePICHandler : public QImageIOHandler
{
public:
virtual bool canRead() const;
virtual bool read(QImage * image);
virtual bool read(QImage *image);
virtual bool write(const QImage &);
virtual QVariant option(ImageOption option) const;

26
src/imageformats/pic_read.cpp
View File

@ -42,9 +42,9 @@ bool picReadHeader(QIODevice *dev, PICHeader *hdr, bool peek)
{
int result = 0;
if (peek) {
result = dev->peek((char*) hdr, HEADER_SIZE);
result = dev->peek((char *) hdr, HEADER_SIZE);
} else {
result = dev->read((char*) hdr, HEADER_SIZE);
result = dev->read((char *) hdr, HEADER_SIZE);
}
hdr->magic = ntohl(hdr->magic);
@ -85,7 +85,7 @@ static bool readChannels(QIODevice *dev, PICChannel *channels, int &bpp)
int c = 0;
memset(channels, 0, sizeof(PICChannel) * 8);
do {
int result = dev->read((char*) & channels[c], CHANNEL_SIZE);
int result = dev->read((char *) & channels[c], CHANNEL_SIZE);
if (result != CHANNEL_SIZE) {
return false;
} else {
@ -164,7 +164,7 @@ static int decodeRLE(QIODevice *dev, void *row, unsigned max, unsigned bpp, unsi
makeComponentMap(channels, component_map);
if (dev->read((char*) buf, 1) != 1) {
if (dev->read((char *) buf, 1) != 1) {
return -1;
}
@ -174,16 +174,16 @@ static int decodeRLE(QIODevice *dev, void *row, unsigned max, unsigned bpp, unsi
if (len > max) {
return -1;
}
unsigned count = dev->read((char*) buf, bpp);
unsigned count = dev->read((char *) buf, bpp);
if (count != bpp) {
return -1;
}
for (unsigned i = 0; i < len; i++) {
pic2RGBA(buf, (unsigned char*)(ptr + i), component_map, bpp);
pic2RGBA(buf, (unsigned char *)(ptr + i), component_map, bpp);
}
} /* If the value is exactly 10000000, it means that it is more than 127 repetitions */
else if (buf[0] == 128) {
unsigned count = dev->read((char*) buf, bpp + 2);
unsigned count = dev->read((char *) buf, bpp + 2);
if (count != bpp + 2) {
return -1;
}
@ -192,7 +192,7 @@ static int decodeRLE(QIODevice *dev, void *row, unsigned max, unsigned bpp, unsi
return -1;
}
for (unsigned i = 0; i < len; i++) {
pic2RGBA(buf + 2, (unsigned char*)(ptr + i), component_map, bpp);
pic2RGBA(buf + 2, (unsigned char *)(ptr + i), component_map, bpp);
}
} /** No repetitions */
else {
@ -200,12 +200,12 @@ static int decodeRLE(QIODevice *dev, void *row, unsigned max, unsigned bpp, unsi
if (len > max) {
return -1;
}
unsigned count = dev->read((char*) buf, len * bpp);
unsigned count = dev->read((char *) buf, len * bpp);
if (count != len * bpp) {
return -1;
}
for (unsigned i = 0; i < len; i++) {
pic2RGBA(buf + (i * bpp), (unsigned char*)(ptr + i), component_map, bpp);
pic2RGBA(buf + (i * bpp), (unsigned char *)(ptr + i), component_map, bpp);
}
}
return len;
@ -236,14 +236,14 @@ static bool readRow(QIODevice *dev, unsigned *row, unsigned width, PICChannel *c
}
} else {
unsigned char component_map[8];
unsigned count = dev->read((char*) row, width * bpp);
unsigned count = dev->read((char *) row, width * bpp);
if (count != width * bpp) {
return false;
}
makeComponentMap(channels[c].channel, component_map);
for (unsigned i = 0; i < width; i++) {
pic2RGBA(((unsigned char*) row) + (i * bpp), (unsigned char*)(row + i), component_map, bpp);
pic2RGBA(((unsigned char *) row) + (i * bpp), (unsigned char *)(row + i), component_map, bpp);
}
}
}
@ -281,7 +281,7 @@ void pic_read(QIODevice *dev, QImage *result)
QImage img(header.width, header.height, QImage::Format_ARGB32);
for (int r = 0; r < header.height; r++) {
unsigned *row = (unsigned*) img.scanLine(r);
unsigned *row = (unsigned *) img.scanLine(r);
std::fill(row, row + header.width, 0);
if (!readRow(dev, row, header.width, channels)) {
FAIL();

2
src/imageformats/pic_rw.h
View File

@ -90,7 +90,6 @@ typedef struct {
#define HEADER_SIZE sizeof(PICHeader)
#define CHANNEL_SIZE sizeof(PICChannel)
/**
* Reads the PIC header and checks that it is OK
* @param dev The QT device to read from
@ -106,5 +105,4 @@ void pic_read(QIODevice *dev, QImage *img);
/// Pic write handler for Qt / KDE
void pic_write(QIODevice *dev, const QImage *img);
#endif//__PIC_RW_H__

16
src/imageformats/pic_write.cpp
View File

@ -54,7 +54,7 @@ static bool writeHeader(QIODevice *dev, std::string msg, unsigned width, unsigne
h.height = htons(height);
h.ratio = 1.0f;
h.fields = htons(BOTH);
count = dev->write((const char*) & h, sizeof(PICHeader));
count = dev->write((const char *) & h, sizeof(PICHeader));
if (count != sizeof(PICHeader)) {
return false;
}
@ -66,7 +66,7 @@ static bool writeHeader(QIODevice *dev, std::string msg, unsigned width, unsigne
if (alpha) {
c.chained = 1;
}
count = dev->write((const char*) & c, sizeof(PICChannel));
count = dev->write((const char *) & c, sizeof(PICChannel));
if (count != sizeof(PICChannel)) {
return false;
}
@ -74,7 +74,7 @@ static bool writeHeader(QIODevice *dev, std::string msg, unsigned width, unsigne
if (alpha) {
c.channel = ALPHA;
c.chained = 0;
count = dev->write((const char*) & c, sizeof(PICChannel));
count = dev->write((const char *) & c, sizeof(PICChannel));
if (count != sizeof(PICChannel)) {
return false;
}
@ -123,7 +123,7 @@ static bool encodeRLE(const unsigned *image, unsigned char *output, bool rgb, un
*out++ = count >> 8;
*out++ = count & 0xFF;
unsigned pixel = convertABGRtoRGBA(*image);
memcpy(out, ((char*) & pixel) + offset, channels);
memcpy(out, ((char *) & pixel) + offset, channels);
out += channels;
oConsumed = count;
oProduced = out - output;
@ -131,7 +131,7 @@ static bool encodeRLE(const unsigned *image, unsigned char *output, bool rgb, un
/* Sequece of < 128 identical pixels */
*out++ = (count + 127);
unsigned pixel = convertABGRtoRGBA(*image);
memcpy(out, ((char*) & pixel) + offset, channels);
memcpy(out, ((char *) & pixel) + offset, channels);
out += channels;
oConsumed = count;
oProduced = out - output;
@ -152,7 +152,7 @@ static bool encodeRLE(const unsigned *image, unsigned char *output, bool rgb, un
in = image;
for (unsigned c = 0; c < count; ++c) {
unsigned pixel = convertABGRtoRGBA(*in);
memcpy(out, ((char*) & pixel) + offset, channels);
memcpy(out, ((char *) & pixel) + offset, channels);
out += channels;
in++;
}
@ -200,7 +200,7 @@ static bool writeRow(QIODevice *dev, unsigned *row, unsigned width, bool alpha)
}
}
dev->write((const char*) buf, posOut);
dev->write((const char *) buf, posOut);
delete[] buf;
return true;
}
@ -220,7 +220,7 @@ void pic_write(QIODevice *dev, const QImage *img)
}
for (int r = 0; r < img->height(); r++) {
unsigned *row = (unsigned*) img->scanLine(r);
unsigned *row = (unsigned *) img->scanLine(r);
if (!writeRow(dev, row, img->width(), alpha)) {
FAIL();
}

48
src/imageformats/psd.cpp
View File

@ -52,7 +52,7 @@ struct PSDHeader {
ushort color_mode;
};
static QDataStream & operator>> (QDataStream & s, PSDHeader & header)
static QDataStream &operator>> (QDataStream &s, PSDHeader &header)
{
s >> header.signature;
s >> header.version;
@ -66,22 +66,23 @@ static QDataStream & operator>> (QDataStream & s, PSDHeader & header)
s >> header.color_mode;
return s;
}
static bool seekBy(QDataStream& s, unsigned int bytes)
static bool seekBy(QDataStream &s, unsigned int bytes)
{
char buf[4096];
while (bytes) {
unsigned int num = qMin(bytes, (unsigned int)sizeof(buf));
unsigned int l = num;
s.readRawData(buf, l);
if (l != num)
if (l != num) {
return false;
}
bytes -= num;
}
return true;
}
// Check that the header is a valid PSD.
static bool IsValid(const PSDHeader & header)
static bool IsValid(const PSDHeader &header)
{
if (header.signature != 0x38425053) { // '8BPS'
return false;
@ -90,7 +91,7 @@ static bool IsValid(const PSDHeader & header)
}
// Check that the header is supported.
static bool IsSupported(const PSDHeader & header)
static bool IsSupported(const PSDHeader &header)
{
if (header.version != 1) {
return false;
@ -108,7 +109,7 @@ static bool IsSupported(const PSDHeader & header)
}
// Load the PSD image.
static bool LoadPSD(QDataStream & s, const PSDHeader & header, QImage & img)
static bool LoadPSD(QDataStream &s, const PSDHeader &header, QImage &img)
{
// Create dst image.
img = QImage(header.width, header.height, QImage::Format_RGB32);
@ -159,19 +160,21 @@ static bool LoadPSD(QDataStream & s, const PSDHeader & header, QImage & img)
if (compression) {
// Skip row lengths.
if (!seekBy(s, header.height * header.channel_count * sizeof(ushort)))
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];
uchar *ptr = img.bits() + components[channel];
uint count = 0;
while (count < pixel_count) {
uchar c;
if (s.atEnd())
if (s.atEnd()) {
return false;
}
s >> c;
uint len = c;
@ -179,8 +182,9 @@ static bool LoadPSD(QDataStream & s, const PSDHeader & header, QImage & img)
// Copy next len+1 bytes literally.
len++;
count += len;
if (count > pixel_count)
if (count > pixel_count) {
return false;
}
while (len != 0) {
s >> *ptr;
@ -193,8 +197,9 @@ static bool LoadPSD(QDataStream & s, const PSDHeader & header, QImage & img)
len ^= 0xFF;
len += 2;
count += len;
if (s.atEnd() || count > pixel_count)
if (s.atEnd() || count > pixel_count) {
return false;
}
uchar val;
s >> val;
while (len != 0) {
@ -214,7 +219,7 @@ static bool LoadPSD(QDataStream & s, const PSDHeader & header, QImage & img)
// Read the data by channel.
for (uint channel = 0; channel < channel_num; channel++) {
uchar * ptr = img.bits() + components[channel];
uchar *ptr = img.bits() + components[channel];
// Read the data.
uint count = pixel_count;
@ -231,7 +236,6 @@ static bool LoadPSD(QDataStream & s, const PSDHeader & header, QImage & img)
} // Private
PSDHandler::PSDHandler()
{
}
@ -288,8 +292,9 @@ bool PSDHandler::canRead(QIODevice *device)
qint64 readBytes = device->read(head, sizeof(head));
if (readBytes != sizeof(head)) {
if (device->isSequential()) {
while (readBytes > 0)
while (readBytes > 0) {
device->ungetChar(head[readBytes-- - 1]);
}
} else {
device->seek(oldPos);
}
@ -297,8 +302,9 @@ bool PSDHandler::canRead(QIODevice *device)
}
if (device->isSequential()) {
while (readBytes > 0)
while (readBytes > 0) {
device->ungetChar(head[readBytes-- - 1]);
}
} else {
device->seek(oldPos);
}
@ -308,16 +314,20 @@ bool PSDHandler::canRead(QIODevice *device)
QImageIOPlugin::Capabilities PSDPlugin::capabilities(QIODevice *device, const QByteArray &format) const
{
if (format == "psd")
if (format == "psd") {
return Capabilities(CanRead);
if (!format.isEmpty())
}
if (!format.isEmpty()) {
return 0;
if (!device->isOpen())
}
if (!device->isOpen()) {
return 0;
}
Capabilities cap;
if (device->isReadable() && PSDHandler::canRead(device))
if (device->isReadable() && PSDHandler::canRead(device)) {
cap |= CanRead;
}
return cap;
}

18
src/imageformats/ras.cpp
View File

@ -51,7 +51,7 @@ struct RasHeader {
enum { SIZE = 32 }; // 8 fields of four bytes each
};
static QDataStream & operator>> (QDataStream & s, RasHeader & head)
static QDataStream &operator>> (QDataStream &s, RasHeader &head)
{
s >> head.MagicNumber;
s >> head.Width;
@ -72,7 +72,7 @@ static QDataStream & operator>> (QDataStream & s, RasHeader & head)
return s;
}
static bool IsSupported(const RasHeader & head)
static bool IsSupported(const RasHeader &head)
{
// check magic number
if (head.MagicNumber != rasMagicBigEndian) {
@ -99,7 +99,7 @@ static bool IsSupported(const RasHeader & head)
return true;
}
static bool LoadRAS(QDataStream & s, const RasHeader & ras, QImage &img)
static bool LoadRAS(QDataStream &s, const RasHeader &ras, QImage &img)
{
s.device()->seek(RasHeader::SIZE);
// Read palette if needed.
@ -278,16 +278,20 @@ bool RASHandler::read(QImage *outImage)
QImageIOPlugin::Capabilities RASPlugin::capabilities(QIODevice *device, const QByteArray &format) const
{
if (format == "ras")
if (format == "ras") {
return Capabilities(CanRead);
if (!format.isEmpty())
}
if (!format.isEmpty()) {
return 0;
if (!device->isOpen())
}
if (!device->isOpen()) {
return 0;
}
Capabilities cap;
if (device->isReadable() && RASHandler::canRead(device))
if (device->isReadable() && RASHandler::canRead(device)) {
cap |= CanRead;
}
return cap;
}

293
src/imageformats/rgb.cpp
View File

@ -7,7 +7,6 @@
// 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
@ -34,13 +33,16 @@ class RLEData : public QVector<uchar>
{
public:
RLEData() {}
RLEData(const uchar *d, uint l, uint o) : _offset(o) {
for (uint i = 0; i < l; i++)
RLEData(const uchar *d, uint l, uint o) : _offset(o)
{
for (uint i = 0; i < l; i++) {
append(d[i]);
}
}
bool operator<(const RLEData&) const;
void write(QDataStream& s);
uint offset() const {
bool operator<(const RLEData &) const;
void write(QDataStream &s);
uint offset() const
{
return _offset;
}
@ -48,14 +50,14 @@ private:
uint _offset;
};
class RLEMap : public QMap<RLEData, uint>
{
public:
RLEMap() : _counter(0), _offset(0) {}
uint insert(const uchar *d, uint l);
QVector<const RLEData*> vector();
void setBaseOffset(uint o) {
QVector<const RLEData *> vector();
void setBaseOffset(uint o)
{
_offset = o;
}
@ -64,15 +66,14 @@ private:
uint _offset;
};
class SGIImage
{
public:
SGIImage(QIODevice *device);
~SGIImage();
bool readImage(QImage&);
bool writeImage(const QImage&);
bool readImage(QImage &);
bool writeImage(const QImage &);
private:
enum { NORMAL, DITHERED, SCREEN, COLORMAP }; // colormap
@ -95,16 +96,16 @@ private:
QByteArray _data;
QByteArray::Iterator _pos;
RLEMap _rlemap;
QVector<const RLEData*> _rlevector;
QVector<const RLEData *> _rlevector;
uint _numrows;
bool readData(QImage&);
bool readData(QImage &);
bool getRow(uchar *dest);
void writeHeader();
void writeRle();
void writeVerbatim(const QImage&);
bool scanData(const QImage&);
void writeVerbatim(const QImage &);
bool scanData(const QImage &);
uint compact(uchar *, uchar *);
uchar intensity(uchar);
};
@ -117,24 +118,22 @@ SGIImage::SGIImage(QIODevice *io) :
_stream.setDevice(_dev);
}
SGIImage::~SGIImage()
{
delete[] _starttab;
delete[] _lengthtab;
}
///////////////////////////////////////////////////////////////////////////////
bool SGIImage::getRow(uchar *dest)
{
int n, i;
if (!_rle) {
for (i = 0; i < _xsize; i++) {
if (_pos >= _data.end())
if (_pos >= _data.end()) {
return false;
}
dest[i] = uchar(*_pos);
_pos += _bpc;
}
@ -142,11 +141,13 @@ bool SGIImage::getRow(uchar *dest)
}
for (i = 0; i < _xsize;) {
if (_bpc == 2)
if (_bpc == 2) {
_pos++;
}
n = *_pos & 0x7f;
if (!n)
if (!n) {
break;
}
if (*_pos++ & 0x80) {
for (; i < _xsize && n--; i++) {
@ -154,8 +155,9 @@ bool SGIImage::getRow(uchar *dest)
_pos += _bpc;
}
} else {
for (; i < _xsize && n--; i++)
for (; i < _xsize && n--; i++) {
*dest++ = *_pos;
}
_pos += _bpc;
}
@ -163,8 +165,7 @@ bool SGIImage::getRow(uchar *dest)
return i == _xsize;
}
bool SGIImage::readData(QImage& img)
bool SGIImage::readData(QImage &img)
{
QRgb *c;
quint32 *start = _starttab;
@ -172,62 +173,76 @@ bool SGIImage::readData(QImage& img)
uchar *line = (uchar *)lguard.data();
unsigned x, y;
if (!_rle)
if (!_rle) {
_pos = _data.begin();
for (y = 0; y < _ysize; y++) {
if (_rle)
_pos = _data.begin() + *start++;
if (!getRow(line))
return false;
c = (QRgb *)img.scanLine(_ysize - y - 1);
for (x = 0; x < _xsize; x++, c++)
*c = qRgb(line[x], line[x], line[x]);
}
if (_zsize == 1)
for (y = 0; y < _ysize; y++) {
if (_rle) {
_pos = _data.begin() + *start++;
}
if (!getRow(line)) {
return false;
}
c = (QRgb *)img.scanLine(_ysize - y - 1);
for (x = 0; x < _xsize; x++, c++) {
*c = qRgb(line[x], line[x], line[x]);
}
}
if (_zsize == 1) {
return true;
}
if (_zsize != 2) {
for (y = 0; y < _ysize; y++) {
if (_rle)
if (_rle) {
_pos = _data.begin() + *start++;
if (!getRow(line))
}
if (!getRow(line)) {
return false;
}
c = (QRgb *)img.scanLine(_ysize - y - 1);
for (x = 0; x < _xsize; x++, c++)
for (x = 0; x < _xsize; x++, c++) {
*c = qRgb(qRed(*c), line[x], line[x]);
}
}
for (y = 0; y < _ysize; y++) {
if (_rle)
if (_rle) {
_pos = _data.begin() + *start++;
if (!getRow(line))
}
if (!getRow(line)) {
return false;
}
c = (QRgb *)img.scanLine(_ysize - y - 1);
for (x = 0; x < _xsize; x++, c++)
for (x = 0; x < _xsize; x++, c++) {
*c = qRgb(qRed(*c), qGreen(*c), line[x]);
}
}
if (_zsize == 3)
if (_zsize == 3) {
return true;
}
}
for (y = 0; y < _ysize; y++) {
if (_rle)
if (_rle) {
_pos = _data.begin() + *start++;
if (!getRow(line))
}
if (!getRow(line)) {
return false;
}
c = (QRgb *)img.scanLine(_ysize - y - 1);
for (x = 0; x < _xsize; x++, c++)
for (x = 0; x < _xsize; x++, c++) {
*c = qRgba(qRed(*c), qGreen(*c), qBlue(*c), line[x]);
}
}
return true;
}
bool SGIImage::readImage(QImage& img)
bool SGIImage::readImage(QImage &img)
{
qint8 u8;
qint16 u16;
@ -237,14 +252,16 @@ bool SGIImage::readImage(QImage& img)
// magic
_stream >> u16;
if (u16 != 0x01da)
if (u16 != 0x01da) {
return false;
}
// verbatim/rle
_stream >> _rle;
// qDebug() << (_rle ? "RLE" : "verbatim");
if (_rle > 1)
if (_rle > 1) {
return false;
}
// bytes per channel
_stream >> _bpc;
@ -253,14 +270,16 @@ bool SGIImage::readImage(QImage& img)
;
else if (_bpc == 2) {
// qDebug() << "dropping least significant byte";
} else
} else {
return false;
}
// number of dimensions
_stream >> _dim;
// qDebug() << "dimensions: " << _dim;
if (_dim < 1 || _dim > 3)
if (_dim < 1 || _dim > 3) {
return false;
}
_stream >> _xsize >> _ysize >> _zsize >> _pixmin >> _pixmax >> u32;
// qDebug() << "x: " << _xsize;
@ -273,27 +292,30 @@ bool SGIImage::readImage(QImage& img)
_stream >> _colormap;
// qDebug() << "colormap: " << _colormap;
if (_colormap != NORMAL)
return false; // only NORMAL supported
if (_colormap != NORMAL) {
return false; // only NORMAL supported
}
for (int i = 0; i < 404; i++)
for (int i = 0; i < 404; i++) {
_stream >> u8;
}
if (_dim == 1) {
// qDebug() << "1-dimensional images aren't supported yet";
return false;
}
if (_stream.atEnd())
if (_stream.atEnd()) {
return false;
}
_numrows = _ysize * _zsize;
img = QImage(_xsize, _ysize, QImage::Format_RGB32);
if (_zsize == 2 || _zsize == 4)
if (_zsize == 2 || _zsize == 4) {
img = img.convertToFormat(QImage::Format_ARGB32);
else if (_zsize > 4) {
} else if (_zsize > 4) {
// qDebug() << "using first 4 of " << _zsize << " channels";
}
@ -306,8 +328,9 @@ bool SGIImage::readImage(QImage& img)
}
_lengthtab = new quint32[_numrows];
for (l = 0; l < _numrows; l++)
for (l = 0; l < _numrows; l++) {
_stream >> _lengthtab[l];
}
}
_data = _dev->readAll();
@ -329,84 +352,87 @@ bool SGIImage::readImage(QImage& img)
return true;
}
///////////////////////////////////////////////////////////////////////////////
void RLEData::write(QDataStream& s)
void RLEData::write(QDataStream &s)
{
for (int i = 0; i < size(); i++)
for (int i = 0; i < size(); i++) {
s << at(i);
}
}
bool RLEData::operator<(const RLEData& b) const
bool RLEData::operator<(const RLEData &b) const
{
uchar ac, bc;
for (int i = 0; i < qMin(size(), b.size()); i++) {
ac = at(i);
bc = b[i];
if (ac != bc)
if (ac != bc) {
return ac < bc;
}
}
return size() < b.size();
}
uint RLEMap::insert(const uchar *d, uint l)
{
RLEData data = RLEData(d, l, _offset);
Iterator it = find(data);
if (it != end())
if (it != end()) {
return it.value();
}
_offset += l;
return QMap<RLEData, uint>::insert(data, _counter++).value();
}
QVector<const RLEData*> RLEMap::vector()
QVector<const RLEData *> RLEMap::vector()
{
QVector<const RLEData*> v(size());
for (Iterator it = begin(); it != end(); ++it)
QVector<const RLEData *> v(size());
for (Iterator it = begin(); it != end(); ++it) {
v.replace(it.value(), &it.key());
}
return v;
}
uchar SGIImage::intensity(uchar c)
{
if (c < _pixmin)
if (c < _pixmin) {
_pixmin = c;
if (c > _pixmax)
}
if (c > _pixmax) {
_pixmax = c;
}
return c;
}
uint SGIImage::compact(uchar *d, uchar *s)
{
uchar *dest = d, *src = s, patt, *t, *end = s + _xsize;
int i, n;
while (src < end) {
for (n = 0, t = src; t + 2 < end && !(*t == t[1] && *t == t[2]); t++)
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--)
while (i--) {
*dest++ = *src++;
}
}
if (src == end)
if (src == end) {
break;
}
patt = *src++;
for (n = 1; src < end && *src == patt; src++)
for (n = 1; src < end && *src == patt; src++) {
n++;
}
while (n) {
i = n > 126 ? 126 : n;
@ -419,8 +445,7 @@ uint SGIImage::compact(uchar *d, uchar *s)
return dest - d;
}
bool SGIImage::scanData(const QImage& img)
bool SGIImage::scanData(const QImage &img)
{
quint32 *start = _starttab;
QByteArray lineguard(_xsize * 2, 0);
@ -433,40 +458,46 @@ bool SGIImage::scanData(const QImage& img)
for (y = 0; y < _ysize; y++) {
c = reinterpret_cast<const QRgb *>(img.scanLine(_ysize - y - 1));
for (x = 0; x < _xsize; x++)
for (x = 0; x < _xsize; x++) {
buf[x] = intensity(qRed(*c++));
}
len = compact(line, buf);
*start++ = _rlemap.insert(line, len);
}
if (_zsize == 1)
if (_zsize == 1) {
return true;
}
if (_zsize != 2) {
for (y = 0; y < _ysize; y++) {
c = reinterpret_cast<const QRgb *>(img.scanLine(_ysize - y - 1));
for (x = 0; x < _xsize; x++)
for (x = 0; x < _xsize; x++) {
buf[x] = intensity(qGreen(*c++));
}
len = compact(line, buf);
*start++ = _rlemap.insert(line, len);
}
for (y = 0; y < _ysize; y++) {
c = reinterpret_cast<const QRgb *>(img.scanLine(_ysize - y - 1));
for (x = 0; x < _xsize; x++)
for (x = 0; x < _xsize; x++) {
buf[x] = intensity(qBlue(*c++));
}
len = compact(line, buf);
*start++ = _rlemap.insert(line, len);
}
if (_zsize == 3)
if (_zsize == 3) {
return true;
}
}
for (y = 0; y < _ysize; y++) {
c = reinterpret_cast<const QRgb *>(img.scanLine(_ysize - y - 1));
for (x = 0; x < _xsize; x++)
for (x = 0; x < _xsize; x++) {
buf[x] = intensity(qAlpha(*c++));
}
len = compact(line, buf);
*start++ = _rlemap.insert(line, len);
}
@ -474,7 +505,6 @@ bool SGIImage::scanData(const QImage& img)
return true;
}
void SGIImage::writeHeader()
{
_stream << quint16(0x01da);
@ -483,16 +513,17 @@ void SGIImage::writeHeader()
_stream << _pixmin << _pixmax;
_stream << quint32(0);
for (int i = 0; i < 80; i++)
for (int i = 0; i < 80; i++) {
_imagename[i] = '\0';
}
_stream.writeRawData(_imagename, 80);
_stream << _colormap;
for (int i = 0; i < 404; i++)
for (int i = 0; i < 404; i++) {
_stream << quint8(0);
}
}
void SGIImage::writeRle()
{
_rle = 1;
@ -501,20 +532,22 @@ void SGIImage::writeRle()
uint i;
// write start table
for (i = 0; i < _numrows; i++)
for (i = 0; i < _numrows; i++) {
_stream << quint32(_rlevector[_starttab[i]]->offset());
}
// write length table
for (i = 0; i < _numrows; i++)
for (i = 0; i < _numrows; i++) {
_stream << quint32(_rlevector[_starttab[i]]->size());
}
// write data
for (i = 0; (int)i < _rlevector.size(); i++)
const_cast<RLEData*>(_rlevector[i])->write(_stream);
for (i = 0; (int)i < _rlevector.size(); i++) {
const_cast<RLEData *>(_rlevector[i])->write(_stream);
}
}
void SGIImage::writeVerbatim(const QImage& img)
void SGIImage::writeVerbatim(const QImage &img)
{
_rle = 0;
// qDebug() << "writing verbatim data";
@ -525,49 +558,56 @@ void SGIImage::writeVerbatim(const QImage& img)
for (y = 0; y < _ysize; y++) {
c = reinterpret_cast<const QRgb *>(img.scanLine(_ysize - y - 1));
for (x = 0; x < _xsize; x++)
for (x = 0; x < _xsize; x++) {
_stream << quint8(qRed(*c++));
}
}
if (_zsize == 1)
if (_zsize == 1) {
return;
}
if (_zsize != 2) {
for (y = 0; y < _ysize; y++) {
c = reinterpret_cast<const QRgb *>(img.scanLine(_ysize - y - 1));
for (x = 0; x < _xsize; x++)
for (x = 0; x < _xsize; x++) {
_stream << quint8(qGreen(*c++));
}
}
for (y = 0; y < _ysize; y++) {
c = reinterpret_cast<const QRgb *>(img.scanLine(_ysize - y - 1));
for (x = 0; x < _xsize; x++)
for (x = 0; x < _xsize; x++) {
_stream << quint8(qBlue(*c++));
}
}
if (_zsize == 3)
if (_zsize == 3) {
return;
}
}
for (y = 0; y < _ysize; y++) {
c = reinterpret_cast<const QRgb *>(img.scanLine(_ysize - y - 1));
for (x = 0; x < _xsize; x++)
for (x = 0; x < _xsize; x++) {
_stream << quint8(qAlpha(*c++));
}
}
}
bool SGIImage::writeImage(const QImage& image)
bool SGIImage::writeImage(const QImage &image)
{
// qDebug() << "writing "; // TODO add filename
QImage img = image;
if (img.allGray())
if (img.allGray()) {
_dim = 2, _zsize = 1;
else
} else {
_dim = 3, _zsize = 3;
}
if (img.format() == QImage::Format_ARGB32)
if (img.format() == QImage::Format_ARGB32) {
_dim = 3, _zsize++;
}
img = img.convertToFormat(QImage::Format_RGB32);
if (img.isNull()) {
@ -594,8 +634,9 @@ bool SGIImage::writeImage(const QImage& image)
long verbatim_size = _numrows * _xsize;
long rle_size = _numrows * 2 * sizeof(quint32);
for (int i = 0; i < _rlevector.size(); i++)
for (int i = 0; i < _rlevector.size(); i++) {
rle_size += _rlevector[i]->size();
}
// qDebug() << "minimum intensity: " << _pixmin;
// qDebug() << "maximum intensity: " << _pixmax;
@ -603,22 +644,20 @@ bool SGIImage::writeImage(const QImage& image)
// qDebug() << "total savings: " << (verbatim_size - rle_size) << " bytes";
// qDebug() << "compression: " << (rle_size * 100.0 / verbatim_size) << '%';
if (verbatim_size <= rle_size)
if (verbatim_size <= rle_size) {
writeVerbatim(img);
else
} else {
writeRle();
}
return true;
}
///////////////////////////////////////////////////////////////////////////////
RGBHandler::RGBHandler()
{
}
bool RGBHandler::canRead() const
{
if (canRead(device())) {
@ -628,21 +667,18 @@ bool RGBHandler::canRead() const
return false;
}
bool RGBHandler::read(QImage *outImage)
{
SGIImage sgi(device());
return sgi.readImage(*outImage);
}
bool RGBHandler::write(const QImage &image)
{
SGIImage sgi(device());
return sgi.writeImage(image);
}
bool RGBHandler::canRead(QIODevice *device)
{
if (!device) {
@ -655,8 +691,9 @@ bool RGBHandler::canRead(QIODevice *device)
int readBytes = head.size();
if (device->isSequential()) {
while (readBytes > 0)
while (readBytes > 0) {
device->ungetChar(head[readBytes-- - 1]);
}
} else {
device->seek(oldPos);
@ -668,29 +705,31 @@ bool RGBHandler::canRead(QIODevice *device)
return data.contains(regexp);
}
///////////////////////////////////////////////////////////////////////////////
QImageIOPlugin::Capabilities RGBPlugin::capabilities(QIODevice *device, const QByteArray &format) const
{
if (format == "rgb" || format == "rgba" ||
format == "bw" || format == "sgi")
format == "bw" || format == "sgi") {
return Capabilities(CanRead | CanWrite);
if (!format.isEmpty())
}
if (!format.isEmpty()) {
return 0;
if (!device->isOpen())
}
if (!device->isOpen()) {
return 0;
}
Capabilities cap;
if (device->isReadable() && RGBHandler::canRead(device))
if (device->isReadable() && RGBHandler::canRead(device)) {
cap |= CanRead;
if (device->isWritable())
}
if (device->isWritable()) {
cap |= CanWrite;
}
return cap;
}
QImageIOHandler *RGBPlugin::create(QIODevice *device, const QByteArray &format) const
{
QImageIOHandler *handler = new RGBHandler;

52
src/imageformats/tga.cpp
View File

@ -74,7 +74,7 @@ struct TgaHeader {
enum { SIZE = 18 }; // const static int SIZE = 18;
};
static QDataStream & operator>> (QDataStream & s, TgaHeader & head)
static QDataStream &operator>> (QDataStream &s, TgaHeader &head)
{
s >> head.id_length;
s >> head.colormap_type;
@ -94,7 +94,7 @@ static QDataStream & operator>> (QDataStream & s, TgaHeader & head)
return s;
}
static bool IsSupported(const TgaHeader & head)
static bool IsSupported(const TgaHeader &head)
{
if (head.image_type != TGA_TYPE_INDEXED &&
head.image_type != TGA_TYPE_RGB &&
@ -140,25 +140,26 @@ struct TgaHeaderInfo {
bool rgb;
bool grey;
TgaHeaderInfo(const TgaHeader & tga) : rle(false), pal(false), rgb(false), grey(false) {
TgaHeaderInfo(const TgaHeader &tga) : rle(false), pal(false), rgb(false), grey(false)
{
switch (tga.image_type) {
case TGA_TYPE_RLE_INDEXED:
rle = true;
// no break is intended!
// no break is intended!
case TGA_TYPE_INDEXED:
pal = true;
break;
case TGA_TYPE_RLE_RGB:
rle = true;
// no break is intended!
// no break is intended!
case TGA_TYPE_RGB:
rgb = true;
break;
case TGA_TYPE_RLE_GREY:
rle = true;
// no break is intended!
// no break is intended!
case TGA_TYPE_GREY:
grey = true;
break;
@ -170,9 +171,7 @@ struct TgaHeaderInfo {
}
};
static bool LoadTGA(QDataStream & s, const TgaHeader & tga, QImage &img)
static bool LoadTGA(QDataStream &s, const TgaHeader &tga, QImage &img)
{
// Create image.
img = QImage(tga.width, tga.height, QImage::Format_RGB32);
@ -202,11 +201,11 @@ static bool LoadTGA(QDataStream & s, const TgaHeader & tga, QImage &img)
}
// Allocate image.
uchar * const image = new uchar[size];
uchar *const image = new uchar[size];
if (info.rle) {
// Decode image.
char * dst = (char *)image;
char *dst = (char *)image;
int num = size;
while (num > 0) {
@ -250,10 +249,10 @@ static bool LoadTGA(QDataStream & s, const TgaHeader & tga, QImage &img)
y_end = -1;
}
uchar * src = image;
uchar *src = image;
for (int y = y_start; y != y_end; y += y_step) {
QRgb * scanline = (QRgb *) img.scanLine(y);
QRgb *scanline = (QRgb *) img.scanLine(y);
if (info.pal) {
// Paletted.
@ -299,7 +298,6 @@ static bool LoadTGA(QDataStream & s, const TgaHeader & tga, QImage &img)
} // namespace
TGAHandler::TGAHandler()
{
}
@ -320,7 +318,6 @@ bool TGAHandler::read(QImage *outImage)
QDataStream s(device());
s.setByteOrder(QDataStream::LittleEndian);
// Read image header.
TgaHeader tga;
s >> tga;
@ -338,7 +335,6 @@ bool TGAHandler::read(QImage *outImage)
return false;
}
QImage img;
bool result = LoadTGA(s, tga, img);
@ -347,7 +343,6 @@ bool TGAHandler::read(QImage *outImage)
return false;
}
*outImage = img;
return true;
}
@ -357,10 +352,11 @@ bool TGAHandler::write(const QImage &image)
QDataStream s(device());
s.setByteOrder(QDataStream::LittleEndian);
const QImage& img = image;
const QImage &img = image;
const bool hasAlpha = (img.format() == QImage::Format_ARGB32);
for (int i = 0; i < 12; i++)
for (int i = 0; i < 12; i++) {
s << targaMagic[i];
}
// write header
s << quint16(img.width()); // width
@ -374,8 +370,9 @@ bool TGAHandler::write(const QImage &image)
s << quint8(qBlue(color));
s << quint8(qGreen(color));
s << quint8(qRed(color));
if (hasAlpha)
if (hasAlpha) {
s << quint8(qAlpha(color));
}
}
return true;
@ -413,18 +410,23 @@ bool TGAHandler::canRead(QIODevice *device)
QImageIOPlugin::Capabilities TGAPlugin::capabilities(QIODevice *device, const QByteArray &format) const
{
if (format == "tga")
if (format == "tga") {
return Capabilities(CanRead | CanWrite);
if (!format.isEmpty())
}
if (!format.isEmpty()) {
return 0;
if (!device->isOpen())
}
if (!device->isOpen()) {
return 0;
}
Capabilities cap;
if (device->isReadable() && TGAHandler::canRead(device))
if (device->isReadable() && TGAHandler::canRead(device)) {
cap |= CanRead;
if (device->isWritable())
}
if (device->isWritable()) {
cap |= CanWrite;
}
return cap;
}

599
src/imageformats/xcf.cpp
View File

File diff suppressed because it is too large Load Diff

57
src/imageformats/xview.cpp
View File

@ -18,7 +18,6 @@
static const int b_255_3[] = {0, 85, 170, 255}, // index*255/3
rg_255_7[] = {0, 36, 72, 109, 145, 182, 218, 255}; // index *255/7
XVHandler::XVHandler()
{
}
@ -43,40 +42,47 @@ bool XVHandler::read(QImage *retImage)
// magic number must be "P7 332"
iodev->readLine(str, BUFSIZE);
if (strncmp(str, "P7 332", 6))
if (strncmp(str, "P7 332", 6)) {
return false;
}
// next line #XVVERSION
iodev->readLine(str, BUFSIZE);
if (strncmp(str, "#XVVERSION", 10))
if (strncmp(str, "#XVVERSION", 10)) {
return false;
}
// now it gets interesting, #BUILTIN means we are out.
// if IMGINFO comes, we are happy!
iodev->readLine(str, BUFSIZE);
if (strncmp(str, "#IMGINFO:", 9))
if (strncmp(str, "#IMGINFO:", 9)) {
return false;
}
// after this an #END_OF_COMMENTS signals everything to be ok!
iodev->readLine(str, BUFSIZE);
if (strncmp(str, "#END_OF", 7))
if (strncmp(str, "#END_OF", 7)) {
return false;
}
// now a last line with width, height, maxval which is
// supposed to be 255
iodev->readLine(str, BUFSIZE);
sscanf(str, "%d %d %d", &x, &y, &maxval);
if (maxval != 255)
if (maxval != 255) {
return false;
}
int blocksize = x * y;
if (x < 0 || y < 0 || blocksize < x || blocksize < y)
if (x < 0 || y < 0 || blocksize < x || blocksize < y) {
return false;
}
// now follows a binary block of x*y bytes.
char *block = (char*) malloc(blocksize);
if (!block)
char *block = (char *) malloc(blocksize);
if (!block) {
return false;
}
if (iodev->read(block, blocksize) != blocksize) {
free(block);
@ -114,7 +120,7 @@ bool XVHandler::read(QImage *retImage)
bool XVHandler::write(const QImage &image)
{
QIODevice& f = *(device());
QIODevice &f = *(device());
// Removed "f.open(...)" and "f.close()" (tanghus)
@ -139,19 +145,19 @@ bool XVHandler::write(const QImage &image)
sprintf(str, "%i %i 255\n", w, h);
f.write(str, strlen(str));
QImage tmpImage(image);
if (image.depth() == 1)
if (image.depth() == 1) {
tmpImage = image.convertToFormat(QImage::Format_Indexed8, Qt::AutoColor);
}
uchar* buffer = new uchar[ w ];
uchar *buffer = new uchar[ w ];
for (int py = 0; py < h; py++) {
const uchar *data = tmpImage.scanLine(py);
for (int px = 0; px < w; px++) {
int r, g, b;
if (tmpImage.depth() == 32) {
const QRgb *data32 = (QRgb*) data;
const QRgb *data32 = (QRgb *) data;
r = qRed(*data32) >> 5;
g = qGreen(*data32) >> 5;
b = qBlue(*data32) >> 6;
@ -165,7 +171,7 @@ bool XVHandler::write(const QImage &image)
}
buffer[ px ] = (r << 5) | (g << 2) | b;
}
f.write((const char*)buffer, w);
f.write((const char *)buffer, w);
}
delete[] buffer;
@ -185,8 +191,9 @@ bool XVHandler::canRead(QIODevice *device)
qint64 readBytes = device->read(head, sizeof(head));
if (readBytes != sizeof(head)) {
if (device->isSequential()) {
while (readBytes > 0)
while (readBytes > 0) {
device->ungetChar(head[readBytes-- - 1]);
}
} else {
device->seek(oldPos);
}
@ -194,8 +201,9 @@ bool XVHandler::canRead(QIODevice *device)
}
if (device->isSequential()) {
while (readBytes > 0)
while (readBytes > 0) {
device->ungetChar(head[readBytes-- - 1]);
}
} else {
device->seek(oldPos);
}
@ -205,18 +213,23 @@ bool XVHandler::canRead(QIODevice *device)
QImageIOPlugin::Capabilities XVPlugin::capabilities(QIODevice *device, const QByteArray &format) const
{
if (format == "xv")
if (format == "xv") {
return Capabilities(CanRead | CanWrite);
if (!format.isEmpty())
}
if (!format.isEmpty()) {
return 0;
if (!device->isOpen())
}
if (!device->isOpen()) {
return 0;
}
Capabilities cap;
if (device->isReadable() && XVHandler::canRead(device))
if (device->isReadable() && XVHandler::canRead(device)) {
cap |= CanRead;
if (device->isWritable())
}
if (device->isWritable()) {
cap |= CanWrite;
}
return cap;
}

18
tests/imageconverter.cpp
View File

@ -28,7 +28,7 @@
#include <QImageWriter>
#include <QTextStream>
int main(int argc, char** argv)
int main(int argc, char **argv)
{
QCoreApplication app(argc, argv);
QCoreApplication::addLibraryPath(QLatin1String(PLUGIN_DIR));
@ -42,18 +42,18 @@ int main(int argc, char** argv)
parser.addPositionalArgument(QLatin1String("in"), QLatin1String("input image file"));
parser.addPositionalArgument(QLatin1String("out"), QLatin1String("output image file"));
QCommandLineOption informat(
QStringList() << QLatin1String("i") << QLatin1String("informat"),
QLatin1String("Image format for input file"),
QLatin1String("format"));
QStringList() << QLatin1String("i") << QLatin1String("informat"),
QLatin1String("Image format for input file"),
QLatin1String("format"));
parser.addOption(informat);
QCommandLineOption outformat(
QStringList() << QLatin1String("o") << QLatin1String("outformat"),
QLatin1String("Image format for output file"),
QLatin1String("format"));
QStringList() << QLatin1String("o") << QLatin1String("outformat"),
QLatin1String("Image format for output file"),
QLatin1String("format"));
parser.addOption(outformat);
QCommandLineOption listformats(
QStringList() << QLatin1String("l") << QLatin1String("list"),
QLatin1String("List supported image formats"));
QStringList() << QLatin1String("l") << QLatin1String("list"),
QLatin1String("List supported image formats"));
parser.addOption(listformats);
parser.process(app);