← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/gui/image/qbmphandler.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-08-24 04:09:09 UTC
  • Revision ID: james.westby@ubuntu.com-20050824040909-xmxe9jfr4a0w5671
Tags: upstream-4.0.0
Import upstream version 4.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gui/image/qbmphandler.cpp
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 1992-2005 Trolltech AS. All rights reserved.
 
4
**
 
5
** This file is part of the painting module of the Qt Toolkit.
 
6
**
 
7
** This file may be distributed under the terms of the Q Public License
 
8
** as defined by Trolltech AS of Norway and appearing in the file
 
9
** LICENSE.QPL included in the packaging of this file.
 
10
**
 
11
** This file may be distributed and/or modified under the terms of the
 
12
** GNU General Public License version 2 as published by the Free Software
 
13
** Foundation and appearing in the file LICENSE.GPL included in the
 
14
** packaging of this file.
 
15
**
 
16
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 
17
**   information about Qt Commercial License Agreements.
 
18
** See http://www.trolltech.com/qpl/ for QPL licensing information.
 
19
** See http://www.trolltech.com/gpl/ for GPL licensing information.
 
20
**
 
21
** Contact info@trolltech.com if any conditions of this licensing are
 
22
** not clear to you.
 
23
**
 
24
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 
25
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 
26
**
 
27
****************************************************************************/
 
28
 
 
29
#include "private/qbmphandler_p.h"
 
30
 
 
31
#include <qimage.h>
 
32
#include <qvector.h>
 
33
 
 
34
static void swapPixel01(QImage *image)        // 1-bpp: swap 0 and 1 pixels
 
35
{
 
36
    int i;
 
37
    if (image->depth() == 1 && image->numColors() == 2) {
 
38
        register uint *p = (uint *)image->bits();
 
39
        int nbytes = image->numBytes();
 
40
        for (i=0; i<nbytes/4; i++) {
 
41
            *p = ~*p;
 
42
            p++;
 
43
        }
 
44
        uchar *p2 = (uchar *)p;
 
45
        for (i=0; i<(nbytes&3); i++) {
 
46
            *p2 = ~*p2;
 
47
            p2++;
 
48
        }
 
49
        QRgb t = image->color(0);                // swap color 0 and 1
 
50
        image->setColor(0, image->color(1));
 
51
        image->setColor(1, t);
 
52
    }
 
53
}
 
54
 
 
55
/*
 
56
    QImageIO::defineIOHandler("BMP", "^BM", 0,
 
57
                               read_bmp_image, write_bmp_image);
 
58
*/
 
59
 
 
60
/*****************************************************************************
 
61
  BMP (DIB) image read/write functions
 
62
 *****************************************************************************/
 
63
 
 
64
const int BMP_FILEHDR_SIZE = 14;                // size of BMP_FILEHDR data
 
65
 
 
66
struct BMP_FILEHDR {                                // BMP file header
 
67
    char   bfType[2];                                // "BM"
 
68
    qint32  bfSize;                                // size of file
 
69
    qint16  bfReserved1;
 
70
    qint16  bfReserved2;
 
71
    qint32  bfOffBits;                                // pointer to the pixmap bits
 
72
};
 
73
 
 
74
QDataStream &operator>>(QDataStream &s, BMP_FILEHDR &bf)
 
75
{                                                // read file header
 
76
    s.readRawData(bf.bfType, 2);
 
77
    s >> bf.bfSize >> bf.bfReserved1 >> bf.bfReserved2 >> bf.bfOffBits;
 
78
    return s;
 
79
}
 
80
 
 
81
QDataStream &operator<<(QDataStream &s, const BMP_FILEHDR &bf)
 
82
{                                                // write file header
 
83
    s.writeRawData(bf.bfType, 2);
 
84
    s << bf.bfSize << bf.bfReserved1 << bf.bfReserved2 << bf.bfOffBits;
 
85
    return s;
 
86
}
 
87
 
 
88
 
 
89
const int BMP_OLD  = 12;                        // old Windows/OS2 BMP size
 
90
const int BMP_WIN  = 40;                        // new Windows BMP size
 
91
const int BMP_OS2  = 64;                        // new OS/2 BMP size
 
92
 
 
93
const int BMP_RGB  = 0;                                // no compression
 
94
const int BMP_RLE8 = 1;                                // run-length encoded, 8 bits
 
95
const int BMP_RLE4 = 2;                                // run-length encoded, 4 bits
 
96
const int BMP_BITFIELDS = 3;                        // RGB values encoded in data as bit-fields
 
97
 
 
98
struct BMP_INFOHDR {                                // BMP information header
 
99
    qint32  biSize;                                // size of this struct
 
100
    qint32  biWidth;                                // pixmap width
 
101
    qint32  biHeight;                                // pixmap height
 
102
    qint16  biPlanes;                                // should be 1
 
103
    qint16  biBitCount;                        // number of bits per pixel
 
104
    qint32  biCompression;                        // compression method
 
105
    qint32  biSizeImage;                                // size of image
 
106
    qint32  biXPelsPerMeter;                        // horizontal resolution
 
107
    qint32  biYPelsPerMeter;                        // vertical resolution
 
108
    qint32  biClrUsed;                                // number of colors used
 
109
    qint32  biClrImportant;                        // number of important colors
 
110
};
 
111
 
 
112
 
 
113
QDataStream &operator>>(QDataStream &s, BMP_INFOHDR &bi)
 
114
{
 
115
    s >> bi.biSize;
 
116
    if (bi.biSize == BMP_WIN || bi.biSize == BMP_OS2) {
 
117
        s >> bi.biWidth >> bi.biHeight >> bi.biPlanes >> bi.biBitCount;
 
118
        s >> bi.biCompression >> bi.biSizeImage;
 
119
        s >> bi.biXPelsPerMeter >> bi.biYPelsPerMeter;
 
120
        s >> bi.biClrUsed >> bi.biClrImportant;
 
121
    }
 
122
    else {                                        // probably old Windows format
 
123
        qint16 w, h;
 
124
        s >> w >> h >> bi.biPlanes >> bi.biBitCount;
 
125
        bi.biWidth  = w;
 
126
        bi.biHeight = h;
 
127
        bi.biCompression = BMP_RGB;                // no compression
 
128
        bi.biSizeImage = 0;
 
129
        bi.biXPelsPerMeter = bi.biYPelsPerMeter = 0;
 
130
        bi.biClrUsed = bi.biClrImportant = 0;
 
131
    }
 
132
    return s;
 
133
}
 
134
 
 
135
QDataStream &operator<<(QDataStream &s, const BMP_INFOHDR &bi)
 
136
{
 
137
    s << bi.biSize;
 
138
    s << bi.biWidth << bi.biHeight;
 
139
    s << bi.biPlanes;
 
140
    s << bi.biBitCount;
 
141
    s << bi.biCompression;
 
142
    s << bi.biSizeImage;
 
143
    s << bi.biXPelsPerMeter << bi.biYPelsPerMeter;
 
144
    s << bi.biClrUsed << bi.biClrImportant;
 
145
    return s;
 
146
}
 
147
 
 
148
static int calc_shift(int mask)
 
149
{
 
150
    int result = 0;
 
151
    while (!(mask & 1)) {
 
152
        result++;
 
153
        mask >>= 1;
 
154
    }
 
155
    return result;
 
156
}
 
157
 
 
158
static bool read_dib(QDataStream &s, int offset, int startpos, QImage &image)
 
159
{
 
160
    BMP_INFOHDR bi;
 
161
    QIODevice* d = s.device();
 
162
 
 
163
    s >> bi;                                        // read BMP info header
 
164
    if (d->atEnd())                                // end of stream/file
 
165
        return false;
 
166
#if 0
 
167
    qDebug("offset...........%d", offset);
 
168
    qDebug("startpos.........%d", startpos);
 
169
    qDebug("biSize...........%d", bi.biSize);
 
170
    qDebug("biWidth..........%d", bi.biWidth);
 
171
    qDebug("biHeight.........%d", bi.biHeight);
 
172
    qDebug("biPlanes.........%d", bi.biPlanes);
 
173
    qDebug("biBitCount.......%d", bi.biBitCount);
 
174
    qDebug("biCompression....%d", bi.biCompression);
 
175
    qDebug("biSizeImage......%d", bi.biSizeImage);
 
176
    qDebug("biXPelsPerMeter..%d", bi.biXPelsPerMeter);
 
177
    qDebug("biYPelsPerMeter..%d", bi.biYPelsPerMeter);
 
178
    qDebug("biClrUsed........%d", bi.biClrUsed);
 
179
    qDebug("biClrImportant...%d", bi.biClrImportant);
 
180
#endif
 
181
    int w = bi.biWidth,         h = bi.biHeight,  nbits = bi.biBitCount;
 
182
    int t = bi.biSize,         comp = bi.biCompression;
 
183
    int red_mask, green_mask, blue_mask;
 
184
    int red_shift = 0;
 
185
    int green_shift = 0;
 
186
    int blue_shift = 0;
 
187
    int red_scale = 0;
 
188
    int green_scale = 0;
 
189
    int blue_scale = 0;
 
190
 
 
191
    if (!(nbits == 1 || nbits == 4 || nbits == 8 || nbits == 16 || nbits == 24 || nbits == 32) ||
 
192
        bi.biPlanes != 1 || comp > BMP_BITFIELDS)
 
193
        return false;                                        // weird BMP image
 
194
    if (!(comp == BMP_RGB || (nbits == 4 && comp == BMP_RLE4) ||
 
195
        (nbits == 8 && comp == BMP_RLE8) || ((nbits == 16 || nbits == 32) && comp == BMP_BITFIELDS)))
 
196
         return false;                                // weird compression type
 
197
 
 
198
    int ncols = 0;
 
199
    int depth = 0;
 
200
    QImage::Format format;
 
201
    switch (nbits) {
 
202
        case 32:
 
203
        case 24:
 
204
        case 16:
 
205
            depth = 32;
 
206
            format = QImage::Format_RGB32;
 
207
            break;
 
208
        case 8:
 
209
        case 4:
 
210
            depth = 8;
 
211
            format = QImage::Format_Indexed8;
 
212
            break;
 
213
        default:
 
214
            depth = 1;
 
215
            format = QImage::Format_Mono;
 
216
    }
 
217
 
 
218
    image = QImage(w, h, format);
 
219
    if (image.isNull())                        // could not create image
 
220
        return false;
 
221
 
 
222
    if (depth != 32) {
 
223
        ncols = bi.biClrUsed ? bi.biClrUsed : 1 << nbits;
 
224
        image.setNumColors(ncols);
 
225
    }
 
226
 
 
227
    image.setDotsPerMeterX(bi.biXPelsPerMeter);
 
228
    image.setDotsPerMeterY(bi.biYPelsPerMeter);
 
229
 
 
230
    d->seek(startpos + BMP_FILEHDR_SIZE + bi.biSize); // goto start of colormap
 
231
 
 
232
    if (ncols > 0) {                                // read color table
 
233
        uchar rgb[4];
 
234
        int   rgb_len = t == BMP_OLD ? 3 : 4;
 
235
        for (int i=0; i<ncols; i++) {
 
236
            if (d->read((char *)rgb, rgb_len) != rgb_len)
 
237
                return false;
 
238
            image.setColor(i, qRgb(rgb[2],rgb[1],rgb[0]));
 
239
            if (d->atEnd())                        // truncated file
 
240
                return false;
 
241
        }
 
242
    } else if (comp == BMP_BITFIELDS && (nbits == 16 || nbits == 32)) {
 
243
        if (d->read((char *)&red_mask, sizeof(red_mask)) != sizeof(red_mask))
 
244
            return false;
 
245
        if (d->read((char *)&green_mask, sizeof(green_mask)) != sizeof(green_mask))
 
246
            return false;
 
247
        if (d->read((char *)&blue_mask, sizeof(blue_mask)) != sizeof(blue_mask))
 
248
            return false;
 
249
        red_shift = calc_shift(red_mask);
 
250
        red_scale = 256 / ((red_mask >> red_shift) + 1);
 
251
        green_shift = calc_shift(green_mask);
 
252
        green_scale = 256 / ((green_mask >> green_shift) + 1);
 
253
        blue_shift = calc_shift(blue_mask);
 
254
        blue_scale = 256 / ((blue_mask >> blue_shift) + 1);
 
255
    } else if (comp == BMP_RGB && (nbits == 24 || nbits == 32)) {
 
256
        blue_mask = 0x000000ff;
 
257
        green_mask = 0x0000ff00;
 
258
        red_mask = 0x00ff0000;
 
259
        blue_shift = 0;
 
260
        green_shift = 8;
 
261
        red_shift = 16;
 
262
        blue_scale = green_scale = red_scale = 1;
 
263
    } else if (comp == BMP_RGB && nbits == 16)  // don't support RGB values for 15/16 bpp
 
264
        return false;
 
265
 
 
266
    // offset can be bogus, be careful
 
267
    if (offset>=0 && startpos + offset > d->pos())
 
268
        d->seek(startpos + offset);                // start of image data
 
269
 
 
270
    int             bpl = image.bytesPerLine();
 
271
#ifdef Q_WS_QWS
 
272
    //
 
273
    // Guess the number of bytes-per-line if we don't know how much
 
274
    // image data is in the file (bogus image ?).
 
275
    //
 
276
    int bmpbpl = bi.biSizeImage > 0 ?
 
277
        bi.biSizeImage / bi.biHeight :
 
278
        (d->size() - offset) / bi.biHeight;
 
279
    int pad = bmpbpl-bpl;
 
280
#endif
 
281
    uchar *data = image.bits();
 
282
 
 
283
    if (nbits == 1) {                                // 1 bit BMP image
 
284
        while (--h >= 0) {
 
285
            if (d->read((char*)(data + h*bpl), bpl) != bpl)
 
286
                break;
 
287
#ifdef Q_WS_QWS
 
288
            if (pad > 0)
 
289
                d->seek(d->pos()+pad);
 
290
#endif
 
291
        }
 
292
        if (ncols == 2 && qGray(image.color(0)) < qGray(image.color(1)))
 
293
            swapPixel01(&image);                // pixel 0 is white!
 
294
    }
 
295
 
 
296
    else if (nbits == 4) {                        // 4 bit BMP image
 
297
        int    buflen = ((w+7)/8)*4;
 
298
        uchar *buf    = new uchar[buflen];
 
299
        if (comp == BMP_RLE4) {                // run length compression
 
300
            int x=0, y=0, c, i;
 
301
            char b;
 
302
            register uchar *p = data + (h-1)*bpl;
 
303
            const uchar *endp = p + w;
 
304
            while (y < h) {
 
305
                if (!d->getChar(&b))
 
306
                    break;
 
307
                if (b == 0) {                        // escape code
 
308
                    if (!d->getChar(&b) || b == 1) {
 
309
                        y = h;                // exit loop
 
310
                    } else switch (b) {
 
311
                        case 0:                        // end of line
 
312
                            x = 0;
 
313
                            y++;
 
314
                            p = data + (h-y-1)*bpl;
 
315
                            break;
 
316
                        case 2:                        // delta (jump)
 
317
                        {
 
318
                            char tmp;
 
319
                            d->getChar(&tmp);
 
320
                            x += tmp;
 
321
                            d->getChar(&tmp);
 
322
                            y += tmp;
 
323
                        }
 
324
 
 
325
                            // Protection
 
326
                            if ((uint)x >= (uint)w)
 
327
                                x = w-1;
 
328
                            if ((uint)y >= (uint)h)
 
329
                                y = h-1;
 
330
 
 
331
                            p = data + (h-y-1)*bpl + x;
 
332
                            break;
 
333
                        default:                // absolute mode
 
334
                            // Protection
 
335
                            if (p + b > endp)
 
336
                                b = endp-p;
 
337
 
 
338
                            i = (c = b)/2;
 
339
                            while (i--) {
 
340
                                d->getChar(&b);
 
341
                                *p++ = b >> 4;
 
342
                                *p++ = b & 0x0f;
 
343
                            }
 
344
                            if (c & 1) {
 
345
                                char tmp;
 
346
                                d->getChar(&tmp);
 
347
                                *p++ = tmp >> 4;
 
348
                            }
 
349
                            if ((((c & 3) + 1) & 2) == 2)
 
350
                                d->getChar(0);        // align on word boundary
 
351
                            x += c;
 
352
                    }
 
353
                } else {                        // encoded mode
 
354
                    // Protection
 
355
                    if (p + b > endp)
 
356
                        b = endp-p;
 
357
 
 
358
                    i = (c = b)/2;
 
359
                    d->getChar(&b);                // 2 pixels to be repeated
 
360
                    while (i--) {
 
361
                        *p++ = b >> 4;
 
362
                        *p++ = b & 0x0f;
 
363
                    }
 
364
                    if (c & 1)
 
365
                        *p++ = b >> 4;
 
366
                    x += c;
 
367
                }
 
368
            }
 
369
        } else if (comp == BMP_RGB) {                // no compression
 
370
            while (--h >= 0) {
 
371
                if (d->read((char*)buf,buflen) != buflen)
 
372
                    break;
 
373
                register uchar *p = data + h*bpl;
 
374
                uchar *b = buf;
 
375
                for (int i=0; i<w/2; i++) {        // convert nibbles to bytes
 
376
                    *p++ = *b >> 4;
 
377
                    *p++ = *b++ & 0x0f;
 
378
                }
 
379
                if (w & 1)                        // the last nibble
 
380
                    *p = *b >> 4;
 
381
            }
 
382
        }
 
383
        delete [] buf;
 
384
    }
 
385
 
 
386
    else if (nbits == 8) {                        // 8 bit BMP image
 
387
        if (comp == BMP_RLE8) {                // run length compression
 
388
            int x=0, y=0;
 
389
            quint8 b;
 
390
            register uchar *p = data + (h-1)*bpl;
 
391
            const uchar *endp = p + w;
 
392
            while (y < h) {
 
393
                if (!d->getChar((char *)&b))
 
394
                    break;
 
395
                if (b == 0) {                        // escape code
 
396
                    if (!d->getChar((char *)&b) || b == 1) {
 
397
                            y = h;                // exit loop
 
398
                    } else switch (b) {
 
399
                        case 0:                        // end of line
 
400
                            x = 0;
 
401
                            y++;
 
402
                            p = data + (h-y-1)*bpl;
 
403
                            break;
 
404
                        case 2:                        // delta (jump)
 
405
                            // Protection
 
406
                            if ((uint)x >= (uint)w)
 
407
                                x = w-1;
 
408
                            if ((uint)y >= (uint)h)
 
409
                                y = h-1;
 
410
 
 
411
                            {
 
412
                                char tmp;
 
413
                                d->getChar(&tmp);
 
414
                                x += tmp;
 
415
                                d->getChar(&tmp);
 
416
                                y += tmp;
 
417
                            }
 
418
                            p = data + (h-y-1)*bpl + x;
 
419
                            break;
 
420
                        default:                // absolute mode
 
421
                            // Protection
 
422
                            if (p + b > endp)
 
423
                                b = endp-p;
 
424
 
 
425
                            if (d->read((char *)p, b) != b)
 
426
                                return false;
 
427
                            if ((b & 1) == 1)
 
428
                                d->getChar(0);        // align on word boundary
 
429
                            x += b;
 
430
                            p += b;
 
431
                    }
 
432
                } else {                        // encoded mode
 
433
                    // Protection
 
434
                    if (p + b > endp)
 
435
                        b = endp-p;
 
436
 
 
437
                    char tmp;
 
438
                    d->getChar(&tmp);
 
439
                    memset(p, tmp, b); // repeat pixel
 
440
                    x += b;
 
441
                    p += b;
 
442
                }
 
443
            }
 
444
        } else if (comp == BMP_RGB) {                // uncompressed
 
445
            while (--h >= 0) {
 
446
                if (d->read((char *)data + h*bpl, bpl) != bpl)
 
447
                    break;
 
448
#ifdef Q_WS_QWS
 
449
                if (pad > 0)
 
450
                    d->seek(d->pos()+pad);
 
451
#endif
 
452
            }
 
453
        }
 
454
    }
 
455
 
 
456
    else if (nbits == 16 || nbits == 24 || nbits == 32) { // 16,24,32 bit BMP image
 
457
        register QRgb *p;
 
458
        QRgb  *end;
 
459
        uchar *buf24 = new uchar[bpl];
 
460
        int    bpl24 = ((w*nbits+31)/32)*4;
 
461
        uchar *b;
 
462
        int c;
 
463
 
 
464
        while (--h >= 0) {
 
465
            p = (QRgb *)(data + h*bpl);
 
466
            end = p + w;
 
467
            if (d->read((char *)buf24,bpl24) != bpl24)
 
468
                break;
 
469
            b = buf24;
 
470
            while (p < end) {
 
471
                c = *(uchar*)b | (*(uchar*)(b+1)<<8);
 
472
                if (nbits != 16)
 
473
                    c |= *(uchar*)(b+2)<<16;
 
474
                *p++ = qRgb(((c & red_mask) >> red_shift) * red_scale,
 
475
                                        ((c & green_mask) >> green_shift) * green_scale,
 
476
                                        ((c & blue_mask) >> blue_shift) * blue_scale);
 
477
                b += nbits/8;
 
478
            }
 
479
        }
 
480
        delete[] buf24;
 
481
    }
 
482
 
 
483
    return true;
 
484
}
 
485
 
 
486
// this is also used in qmime_win.cpp
 
487
bool Q_GUI_EXPORT qt_write_dib(QDataStream &s, QImage image)
 
488
{
 
489
    int        nbits;
 
490
    int        bpl_bmp;
 
491
    int        bpl = image.bytesPerLine();
 
492
 
 
493
    QIODevice* d = s.device();
 
494
 
 
495
    if (image.depth() == 8 && image.numColors() <= 16) {
 
496
        bpl_bmp = (((bpl+1)/2+3)/4)*4;
 
497
        nbits = 4;
 
498
    } else if (image.depth() == 32) {
 
499
        bpl_bmp = ((image.width()*24+31)/32)*4;
 
500
        nbits = 24;
 
501
#ifdef Q_WS_QWS
 
502
    } else if (image.depth() == 1 || image.depth() == 8) {
 
503
        // Qt/E doesn't word align.
 
504
        bpl_bmp = ((image.width()*image.depth()+31)/32)*4;
 
505
        nbits = image.depth();
 
506
#endif
 
507
    } else {
 
508
        bpl_bmp = bpl;
 
509
        nbits = image.depth();
 
510
    }
 
511
 
 
512
    BMP_INFOHDR bi;
 
513
    bi.biSize               = BMP_WIN;                // build info header
 
514
    bi.biWidth               = image.width();
 
515
    bi.biHeight               = image.height();
 
516
    bi.biPlanes               = 1;
 
517
    bi.biBitCount      = nbits;
 
518
    bi.biCompression   = BMP_RGB;
 
519
    bi.biSizeImage     = bpl_bmp*image.height();
 
520
    bi.biXPelsPerMeter = image.dotsPerMeterX() ? image.dotsPerMeterX()
 
521
                                                : 2834; // 72 dpi default
 
522
    bi.biYPelsPerMeter = image.dotsPerMeterY() ? image.dotsPerMeterY() : 2834;
 
523
    bi.biClrUsed       = image.numColors();
 
524
    bi.biClrImportant  = image.numColors();
 
525
    s << bi;                                        // write info header
 
526
 
 
527
    if (image.depth() != 32) {                // write color table
 
528
        uchar *color_table = new uchar[4*image.numColors()];
 
529
        uchar *rgb = color_table;
 
530
        QVector<QRgb> c = image.colorTable();
 
531
        for (int i=0; i<image.numColors(); i++) {
 
532
            *rgb++ = qBlue (c[i]);
 
533
            *rgb++ = qGreen(c[i]);
 
534
            *rgb++ = qRed  (c[i]);
 
535
            *rgb++ = 0;
 
536
        }
 
537
        d->write((char *)color_table, 4*image.numColors());
 
538
        delete [] color_table;
 
539
    }
 
540
 
 
541
    if (image.format() == QImage::Format_MonoLSB)
 
542
        image = image.convertToFormat(QImage::Format_Mono);
 
543
 
 
544
    int y;
 
545
 
 
546
    if (nbits == 1 || nbits == 8) {                // direct output
 
547
#ifdef Q_WS_QWS
 
548
        // Qt/E doesn't word align.
 
549
        int pad = bpl_bmp - bpl;
 
550
        char padding[4];
 
551
#endif
 
552
        for (y=image.height()-1; y>=0; y--) {
 
553
            d->write((char*)image.scanLine(y), bpl);
 
554
#ifdef Q_WS_QWS
 
555
            d->write(padding, pad);
 
556
#endif
 
557
        }
 
558
        return true;
 
559
    }
 
560
 
 
561
    uchar *buf        = new uchar[bpl_bmp];
 
562
    uchar *b, *end;
 
563
    register uchar *p;
 
564
 
 
565
    memset(buf, 0, bpl_bmp);
 
566
    for (y=image.height()-1; y>=0; y--) {        // write the image bits
 
567
        if (nbits == 4) {                        // convert 8 -> 4 bits
 
568
            p = image.scanLine(y);
 
569
            b = buf;
 
570
            end = b + image.width()/2;
 
571
            while (b < end) {
 
572
                *b++ = (*p << 4) | (*(p+1) & 0x0f);
 
573
                p += 2;
 
574
            }
 
575
            if (image.width() & 1)
 
576
                *b = *p << 4;
 
577
        } else {                                // 32 bits
 
578
            QRgb *p   = (QRgb *)image.scanLine(y);
 
579
            QRgb *end = p + image.width();
 
580
            b = buf;
 
581
            while (p < end) {
 
582
                *b++ = qBlue(*p);
 
583
                *b++ = qGreen(*p);
 
584
                *b++ = qRed(*p);
 
585
                p++;
 
586
            }
 
587
        }
 
588
        if (bpl_bmp != d->write((char*)buf, bpl_bmp)) {
 
589
            delete[] buf;
 
590
            return false;
 
591
        }
 
592
    }
 
593
    delete[] buf;
 
594
    return true;
 
595
}
 
596
 
 
597
// this is also used in qmime_win.cpp
 
598
bool Q_GUI_EXPORT qt_read_dib(QDataStream &s, QImage &image)
 
599
{
 
600
    return read_dib(s,-1,-BMP_FILEHDR_SIZE,image);
 
601
}
 
602
 
 
603
bool QBmpHandler::canRead() const
 
604
{
 
605
    return canRead(device());
 
606
}
 
607
 
 
608
bool QBmpHandler::canRead(QIODevice *device)
 
609
{
 
610
    if (!device) {
 
611
        qWarning("QBmpHandler::canRead() called with 0 pointer");
 
612
        return false;
 
613
    }
 
614
 
 
615
    qint64 oldPos = device->pos();
 
616
 
 
617
    char head[2];
 
618
    qint64 readBytes = device->read(head, sizeof(head));
 
619
    if (readBytes != sizeof(head)) {
 
620
        if (device->isSequential()) {
 
621
            while (readBytes > 0)
 
622
                device->ungetChar(head[readBytes-- - 1]);
 
623
        } else {
 
624
            device->seek(oldPos);
 
625
        }
 
626
        return false;
 
627
    }
 
628
 
 
629
    if (device->isSequential()) {
 
630
        while (readBytes > 0)
 
631
            device->ungetChar(head[readBytes-- - 1]);
 
632
    } else {
 
633
        device->seek(oldPos);
 
634
    }
 
635
 
 
636
    return (qstrncmp(head, "BM", 2) == 0);
 
637
}
 
638
 
 
639
bool QBmpHandler::read(QImage *image)
 
640
{
 
641
    QIODevice *d = device();
 
642
    QDataStream s(d);
 
643
    BMP_FILEHDR bf = {{0, 0}, 0, 0, 0, 0};
 
644
    int startpos = d->pos();
 
645
 
 
646
    // Intel byte order
 
647
    s.setByteOrder(QDataStream::LittleEndian);
 
648
 
 
649
    // read BMP file header
 
650
    s >> bf;
 
651
 
 
652
    // check header
 
653
    if (qstrncmp(bf.bfType,"BM",2) != 0)
 
654
        return false;
 
655
 
 
656
    // read image
 
657
    QImage tmpImage;
 
658
    if (!read_dib(s, bf.bfOffBits, startpos, tmpImage))
 
659
        return false;
 
660
 
 
661
    if (image)
 
662
        *image = tmpImage;
 
663
    return true;
 
664
}
 
665
 
 
666
bool QBmpHandler::write(const QImage &image)
 
667
{
 
668
    QIODevice *d = device();
 
669
    QDataStream s(d);
 
670
    BMP_FILEHDR bf;
 
671
    int bpl_bmp;
 
672
    int bpl = image.bytesPerLine();
 
673
 
 
674
    // Code partially repeated in qt_write_dib
 
675
    if (image.depth() == 8 && image.numColors() <= 16) {
 
676
        bpl_bmp = (((bpl+1)/2+3)/4)*4;
 
677
    } else if (image.depth() == 32) {
 
678
        bpl_bmp = ((image.width()*24+31)/32)*4;
 
679
    } else {
 
680
        bpl_bmp = bpl;
 
681
    }
 
682
 
 
683
    // Intel byte order
 
684
    s.setByteOrder(QDataStream::LittleEndian);
 
685
 
 
686
    // build file header
 
687
    strncpy(bf.bfType, "BM", 2);
 
688
 
 
689
    // write file header
 
690
    bf.bfReserved1 = 0;
 
691
    bf.bfReserved2 = 0;
 
692
    bf.bfOffBits = BMP_FILEHDR_SIZE + BMP_WIN + image.numColors() * 4;
 
693
    bf.bfSize = bf.bfOffBits + bpl_bmp*image.height();
 
694
    s << bf;
 
695
 
 
696
    // write image
 
697
    return qt_write_dib(s, image);
 
698
}
 
699
 
 
700
QByteArray QBmpHandler::name() const
 
701
{
 
702
    return "bmp";
 
703
}