关于 QImage 加载本地大图片的崩溃问题

关于 QImage 加载本地BMP大图片的崩溃问题

问题场景：
图片格式：BMP
图片颜色类型：Format_RGB888、Format_Grayscale8、Format_RGB32
图片大小：50000*50000
Qt版本：5.11.2
编译平台：MSVC 2017 x64

(... 表示部分源码省略展示)

1、问题查找

QImage 的加载流程

QImage reloadImg;
reloadImg.load(fileName);

代码运行在 load 时崩溃，下面我们来看一下，load 函数做了什么事情，为什么会崩溃。

bool QImage::load(const QString &fileName, const char* format)
{QImage image = QImageReader(fileName, format).read();operator=(image);return !isNull();
}

QImageReader(fileName, format).read(); 调用了QImageReader的构造函数和read函数

QImageReader::QImageReader(const QString &fileName, const QByteArray &format): QImageReader(new QFile(fileName), format)
{d->deleteDevice = true;
}
QImageReader::QImageReader(QIODevice *device, const QByteArray &format): d(new QImageReaderPrivate(this))
{d->device = device;d->format = format;
}

QImageReader的构造函数使用了委托构造，QImageReaderPrivate内部持有类的实际内容，而 QIODevice *device 形参传入的 new QFile(fileName) 仅仅是使用多态作为IO接口去加载文件。
这里把QImageReaderPrivate的定义展示出来，笔者写了部分的注释。

class QImageReaderPrivate
{
public:/// 构造函数：绑定外部的 QImageReader 实例QImageReaderPrivate(QImageReader *qq);/// 析构函数：释放资源（如 device、handler 等）~QImageReaderPrivate();//// ==================== 设备与格式相关 ====================///// 文件格式（如 "png"、"jpg"、"bmp" 等）QByteArray format;/// 是否自动检测图像格式（若为 true，则根据文件头判断格式）bool autoDetectImageFormat;/// 是否忽略文件格式与扩展名（例如：强制使用 handler 解析）bool ignoresFormatAndExtension;/// 当前绑定的输入设备（例如 QFile、QBuffer、QByteArray 等）QIODevice *device;/// 是否在析构时自动删除 device（例如用户未显式管理时）bool deleteDevice;/// 当前用于实际解码图像的处理器对象（QImageIOHandler 派生类）QImageIOHandler *handler;/// 初始化 handler（根据 format / device 自动选择解码插件）bool initHandler();//// ==================== 图像选项与读取参数 ====================///// 读取时的裁剪区域（在图像坐标系中）QRect clipRect;/// 缩放后的目标尺寸（若为空则不缩放）QSize scaledSize;/// 缩放后再裁剪的区域（用于优化部分读取）QRect scaledClipRect;/// 图像质量参数（通常用于写入时；某些解码器可能会参考）int quality;/// 图像内嵌文本信息（键值对形式，如 Exif、注释、元数据）QMap<QString, QString> text;/// 从 handler 获取所有文本信息void getText();/// 自动应用图像变换的策略枚举enum {UsePluginDefault,   ///< 使用插件默认行为（由解码器决定是否旋转）ApplyTransform,     ///< 总是应用图像的 EXIF / 方向变换DoNotApplyTransform ///< 不应用任何图像方向变换} autoTransform;//// ==================== 错误状态 ====================///// 最近一次错误的类型（如 不支持的格式、读失败、内存不足 等）QImageReader::ImageReaderError imageReaderError;/// 最近一次错误的字符串描述QString errorString;//// ==================== 关联的外部对象 ====================///// 指向外部的 QImageReader 公有接口类，用于回调与状态同步QImageReader *q;
};

这里的QIODevice *device是本地图片的IO设备指针，QImageIOHandler *handler用来进行关键的加载图片内容的处理操作，在下文中有提及。
构造函数就这么多内容，看不出所以然。下面去看看 QImageReader::read()

QImage QImageReader::read()
{// Because failed image reading might have side effects, we explicitly// return a null image instead of the image we've just created.QImage image;return read(&image) ? image : QImage();
}
bool QImageReader::read(QImage *image)
{...if (!d->handler && !d->initHandler())return false;...// read the imageif (!d->handler->read(image)) {d->imageReaderError = InvalidDataError;d->errorString = QImageReader::tr("Unable to read image data");return false;}...
}

bool QImageReader::read(QImage *image) 内部做了很多关于自动识别图片类型的操作，这里省略展示了这些代码，仅展示关键代码。

对于此文的BMP图片，d->initHandler()函数的实现了：定义d->handler变量为 new QBmpHandler，同时设置handler->setDevice(device),使得d->handler可以持有图片文件的IO设备指针。

接下来是最关键的 d->handler->read(image) 加载图片数据。

bool QBmpHandler::read(QImage *image)
{if (state == Error)return false;if (!image) {qWarning("QBmpHandler::read: cannot read into null pointer");return false;}if (state == Ready && !readHeader()) {state = Error;return false;}QIODevice *d = device();QDataStream s(d);// Intel byte orders.setByteOrder(QDataStream::LittleEndian);// read imageconst bool readSuccess = m_format == BmpFormat ?read_dib_body(s, infoHeader, fileHeader.bfOffBits, startpos, *image) :read_dib_body(s, infoHeader, -1, startpos - BMP_FILEHDR_SIZE, *image);if (!readSuccess)return false;state = Ready;return true;
}

QBmpHandler::read(QImage *image)函数内部的关键是 QBmpHandler::readHeader()函数和read_dib_body()函数。

bool QBmpHandler::readHeader()
{state = Error;QIODevice *d = device();QDataStream s(d);startpos = d->pos();// Intel byte orders.setByteOrder(QDataStream::LittleEndian);// read BMP file headerif (m_format == BmpFormat && !read_dib_fileheader(s, fileHeader))return false;// read BMP info headerif (!read_dib_infoheader(s, infoHeader))return false;state = ReadHeader;return true;
}

先来看看QBmpHandler::readHeader()，内部实现了从IO设备文件中，加载图片的文件头和消息头，可以根据下面BMP文件的存储格式查看。

+-------------------------+
| BMP_FILEHDR (14 bytes)  |  --> 文件头
+-------------------------+
| BMP_INFOHDR (40~124 B)  |  --> 信息头（DIB Header）
+-------------------------+
| Color Table (可选)      |  --> 调色板（灰度/索引图时有）
+-------------------------+
| Pixel Array             |  --> 实际像素数据
+-------------------------+

这是qt内部定义的文件头和消息头结构体，加载存放到变量BMP_FILEHDR fileHeader和BMP_INFOHDR infoHeader中

struct BMP_FILEHDR {char   bfType[2];        // 文件类型，必须是 'B','M'qint32 bfSize;           // 文件总大小（字节）qint16 bfReserved1;      // 保留，一般为 0qint16 bfReserved2;      // 保留，一般为 0qint32 bfOffBits;        // 图像数据起始偏移（从文件头开始的偏移）
};
struct BMP_INFOHDR {qint32  biSize;          // 结构体大小（字节数）qint32  biWidth;         // 图像宽度（像素）qint32  biHeight;        // 图像高度（像素）qint16  biPlanes;        // 平面数，固定为 1qint16  biBitCount;      // 每像素位数 (1,4,8,16,24,32)qint32  biCompression;   // 压缩方式（0=BI_RGB）qint32  biSizeImage;     // 图像数据大小（字节）qint32  biXPelsPerMeter; // 水平分辨率（像素/米）qint32  biYPelsPerMeter; // 垂直分辨率（像素/米）qint32  biClrUsed;       // 实际使用的调色板颜色数qint32  biClrImportant;  // 重要颜色数// 以下是 Windows V4/V5 扩展部分（Qt 兼容处理）quint32 biRedMask;       // 红通道掩码quint32 biGreenMask;     // 绿通道掩码quint32 biBlueMask;      // 蓝通道掩码quint32 biAlphaMask;     // 透明度掩码qint32  biCSType;        // 色彩空间类型（如 LCS_sRGB）qint32  biEndpoints[9];  // 色彩空间端点qint32  biGammaRed;qint32  biGammaGreen;qint32  biGammaBlue;qint32  biIntent;        // 渲染意图（V5）qint32  biProfileData;qint32  biProfileSize;qint32  biReserved;
};

这里提一嘴，BMP_FILEHDR的qint32 bfSize最大值转为无符号类型的内存容量，仅有4096MB的大小，意味着图片大小超过4GB时，实际上的bfSize会越界，所以没有可信度，但是Qt这里并没有使用这个变量，应该也是考虑到了这个问题。
这也解释了为什么有的看图软件无法打开比较大的图片。

下面是关键的static bool read_dib_body(QDataStream &s, const BMP_INFOHDR &bi, qint64 offset, qint64 startpos, QImage &image)函数

因为确认格式是BmpFormat而不是DibFormat，所以QBmpHandler::read(QImage *image)内部调用的逻辑，简化后是:

const bool readSuccess = read_dib_body(s, infoHeader, fileHeader.bfOffBits, startpos, *image)

这里的传参，s为文件数据流，infoHeader为消息头，fileHeader.bfOffBits为图像数据起始偏移，startpos基本为0，代表文件头数据位置，*image为存放图片的对象

因为read_dib_body函数太长，这里仅展示Format_RGB888、Format_Grayscale8、Format_RGB32 的内容，具体的源码可以看文章最后的源代码章节

static bool read_dib_body(QDataStream &s, const BMP_INFOHDR &bi, qint64 offset, qint64 startpos, QImage &image)
{...QImage::Format format;switch (nbits) {case 32:case 24:case 16:depth = 32;format = transp ? QImage::Format_ARGB32 : QImage::Format_RGB32;break;case 8:case 4:depth = 8;format = QImage::Format_Indexed8;break;default:depth = 1;format = QImage::Format_Mono;}...if (image.size() != QSize(w, h) || image.format() != format) {image = QImage(w, h, format);if (image.isNull())                        // could not create imagereturn false;if (ncols)image.setColorCount(ncols);            // Ensure valid QImage}...int bpl = image.bytesPerLine();uchar *data = image.bits();if (nbits == 1) {                                // 1 bit BMP image...}else if (nbits == 4) {                        // 4 bit BMP image...}else if (nbits == 8) {                        // 8 bit BMP imageif (comp == BMP_RLE8) {                // run length compression...} else if (comp == BMP_RGB) {                // uncompressedwhile (--h >= 0) {if (d->read((char *)data + h*bpl, bpl) != bpl)break;}}}else if (nbits == 16 || nbits == 24 || nbits == 32) { // 16,24,32 bit BMP imageQRgb *p;QRgb  *end;uchar *buf24 = new uchar[bpl];int    bpl24 = ((w*nbits+31)/32)*4;uchar *b;int c;while (--h >= 0) {p = (QRgb *)(data + h*bpl);end = p + w;if (d->read((char *)buf24,bpl24) != bpl24)break;b = buf24;while (p < end) {c = *(uchar*)b | (*(uchar*)(b+1)<<8);if (nbits > 16)c |= *(uchar*)(b+2)<<16;if (nbits > 24)c |= *(uchar*)(b+3)<<24;*p++ = qRgba(((c & red_mask) >> red_shift) * red_scale,((c & green_mask) >> green_shift) * green_scale,((c & blue_mask) >> blue_shift) * blue_scale,transp ? ((c & alpha_mask) >> alpha_shift) * alpha_scale : 0xff);b += nbits/8;}}delete[] buf24;}...
}

因为BMP格式存放数据时，是从按行倒序存放的，所以这里加载时，也是高度的倒序加载。

下面分别讲一下，这三种颜色格式的调用流程：

• Format_RGB888

    nbits = 24; 表示RGB三个颜色   depth = 32; 表示虽然你是24位的图片，但是QImage按照32位来申请内存空间和存放数据  image = QImage(w, h, format); 申请内存空间  int bpl = image.bytesPerLine(); 每行字节数，因为是32位深度，所以等于 4 * w  uchar *data = image.bits(); 目标存放数据的源地址的头指针  （QImage内部每个4字节，也就是一个int，存放一个像素的数据，顺序格式为ARGB，这里A通道不使用，为默认值0XFF）  循环加载每行的数据：  QRgb *p = (QRgb *)(data + h*bpl);本质上是uint*，用来遍历每一行的像素，指向某一高度指针的头像素指针基地址  每一行数据，本地文件内存放的（byte）字节格式为：BGR通道的循环  所以，c = *(uchar*)b | (*(uchar*)(b+1)<<8); c |= *(uchar*)(b+2)<<16; 加载每一个像素  然后传给p指针，并指针偏移  
  

• Format_RGB32

    nbits = 32; 表示ARGB四个颜色   depth = 32; 表示QImage按照32位来申请内存空间和存放数据  image = QImage(w, h, format); 申请内存空间  int bpl = image.bytesPerLine(); 每行字节数，因为是32位深度，所以等于 4 * w  uchar *data = image.bits(); 目标存放数据的源地址的头指针  （QImage内部每个4字节，也就是一个int，存放一个像素的数据，顺序格式为ARGB）  循环加载每行的数据：  QRgb *p = (QRgb *)(data + h*bpl);本质上是uint*，用来遍历每一行的像素，指向某一高度指针的头像素指针基地址  每一行数据，本地文件内存放的（byte）字节格式为：BGRA通道的循环  所以，c = *(uchar*)b | (*(uchar*)(b+1)<<8); c |= *(uchar*)(b+2)<<16; c |= *(uchar*)(b+3)<<24; 加载每一个像素  然后传给p指针，并指针偏移  
  

• Format_Grayscale8

    nbits = 8; 表示黑白颜色   depth = 8; 表示QImage按照8位来申请内存空间和存放数据  image = QImage(w, h, format); 申请内存空间  int bpl = image.bytesPerLine(); 每行字节数，因为是8位深度，所以等于 1 * w  uchar *data = image.bits(); 目标存放数据的源地址的头指针  黑白图会有调色板，这里不详细说明过程（每个1字节，存放一个像素的数据）  循环加载每行的数据：  因为没有顺序的要求，可以直接按行加载每一行即可。  (char *)data + h*bpl为每一行的头像素指针地址。  while (--h >= 0) {if (d->read((char *)data + h*bpl, bpl) != bpl)break;}
  

可以看到Format_RGB888和Format_RGB32大致上差不多

好了，我们费了九牛二虎之力，终于到了崩溃的地方，也就是：

    // 黑白图崩溃行if (d->read((char *)data + h*bpl, bpl) != bpl)// 彩色图崩溃行*p++ = qRgba(((c & red_mask) >> red_shift) * red_scale,((c & green_mask) >> green_shift) * green_scale,((c & blue_mask) >> blue_shift) * blue_scale,transp ? ((c & alpha_mask) >> alpha_shift) * alpha_scale : 0xff);

那么这里有什么问题呢，我们回想一下崩溃的一个特定条件：大图，50000*50000的宽度

结合崩溃的提示信息，p指针越界和read内部指针越界，那么我们可以猜测到，可能是p指针的计算的问题。

现在我们仔细回味一下p指针的计算，一个是(char *)data + h*bpl，另一个是(QRgb *)data + h*bpl

此时已经发现不对了，看一下h和bpl的定义，分别为int h = bi.biHeight;、int bpl = image.bytesPerLine();

以黑白图举例，假设为第一行，h为49999，bpl为50000，计算的偏移为2499950000，转为二进制0b 1001 0101 0000 0010 0011 0101 1011 0000

好，那么好，水落石出。

计算的结果为int型，第一个bit为符号位，实际作为偏移时，是作为负数-1795017296来参与计算的，也就是以为了实际的p指针是在向前偏移，所以会出现指针越界的问题。

这里也就找到了问题所在，去检查了一下其他不同通道数nbits的加载过程，都是由一样的处理，这里观察了一下计算指针时的变量，发现都是用了bpl这个变量

那么只需将类型修改为qint64即可，这样计算偏移时，会自动转为qint64的长度，也就不会越界。如下：

    qint64 bpl = image.bytesPerLine();

2、问题解决

打开 .\qt-everywhere-src-5.11.2\qtbase\src\gui\image\qbmphandler.cpp 文件

将其中 read_dib_body 函数的 int bpl = image.bytesPerLine(); ，修改为 qint64 bpl = image.bytesPerLine();

重新编译即可。

3、验证测试例程

下面为测试代码，验证修改后的可行性。

#include <QCoreApplication>
#include <QImage>
#include <QDebug>
#include <QString>int main(int argc, char* argv[])
{QCoreApplication a(argc, argv);int width = 40000;    // starting widthint height = 40000;   // starting heightconst int step = 10000; // step to increase size each iterationconst int maxTry = 10;  // maximum attemptsQString fileName = QString("test.bmp");for (int i = 0; i < maxTry; ++i){qDebug().noquote() << QString("Trying to create QImage: %1 x %2").arg(width).arg(height);try{{QImage img(width, height, QImage::Format_Grayscale8);if (img.isNull()) {qDebug().noquote() << "Creation failed, QImage returned null";break;}// Fill with gradient pattern (pseudo black & white)for (int y = 0; y < height; ++y) {uchar* line = img.scanLine(y);for (int x = 0; x < width; ++x) {line[x] = (x + y) % 256;  // Grayscale value}}// Save as BMPif (!img.save(fileName)) {qDebug().noquote() << "Failed to save: " + fileName;break;}else {qDebug().noquote() << "Saved successfully: " + fileName;}}// Reload imageQImage reloadImg;if (!reloadImg.load(fileName)) {qDebug().noquote() << "Failed to reload: " + fileName;break;}else {qDebug().noquote() << QString("Reloaded successfully: %1 Size: %2 x %3 Bytes: %4").arg(fileName).arg(reloadImg.width()).arg(reloadImg.height()).arg(reloadImg.sizeInBytes());}}catch (std::bad_alloc& e){qDebug().noquote() << QString("Memory allocation failed: %1").arg(e.what());break;}try{{QImage img(width, height, QImage::Format_RGB888);if (img.isNull()) {qDebug().noquote() << "Creation failed, QImage returned null";break;}// Fill with pseudo-color patternfor (int y = 0; y < height; ++y) {uchar* line = img.scanLine(y);for (int x = 0; x < width; ++x) {line[x * 3 + 0] = (x + y) % 256;      // Rline[x * 3 + 1] = (2 * x + y) % 256;  // Gline[x * 3 + 2] = (x + 2 * y) % 256;  // B}}// Save as BMPif (!img.save(fileName)) {qDebug().noquote() << "Failed to save: " + fileName;break;}else {qDebug().noquote() << "Saved successfully: " + fileName;}}// Reload imageQImage reloadImg;if (!reloadImg.load(fileName)) {qDebug().noquote() << "Failed to reload: " + fileName;break;}else {qDebug().noquote() << QString("Reloaded successfully: %1 Size: %2 x %3 Bytes: %4").arg(fileName).arg(reloadImg.width()).arg(reloadImg.height()).arg(reloadImg.sizeInBytes());}}catch (std::bad_alloc& e){qDebug().noquote() << QString("Memory allocation failed: %1").arg(e.what());break;}// Increase sizewidth += step;height += step;}return 0;
}

执行结果

Trying to create QImage: 40000 x 40000
Saved successfully: test.bmp
Reloaded successfully: test.bmp Size: 40000 x 40000 Bytes: 1600000000
Saved successfully: test.bmp
Reloaded successfully: test.bmp Size: 40000 x 40000 Bytes: 6400000000
Trying to create QImage: 50000 x 50000
Saved successfully: test.bmp
Reloaded successfully: test.bmp Size: 50000 x 50000 Bytes: 2500000000
Saved successfully: test.bmp
Reloaded successfully: test.bmp Size: 50000 x 50000 Bytes: 10000000000
Trying to create QImage: 60000 x 60000
Saved successfully: test.bmp
Reloaded successfully: test.bmp Size: 60000 x 60000 Bytes: 3600000000
Saved successfully: test.bmp
Reloaded successfully: test.bmp Size: 60000 x 60000 Bytes: 14400000000
Trying to create QImage: 70000 x 70000
Saved successfully: test.bmp
Reloaded successfully: test.bmp Size: 70000 x 70000 Bytes: 4900000000
QImage: out of memory, returning null image
Saved successfully: test.bmp
Failed to reload: test.bmp

因为笔者的工作机内存仅有16G，过大的图片无法存放在电脑内存，就不再后续测试了

可以看到，相比之前是有优化效果的。

拓展思考

（1）其他类型图片的加载崩溃

其他类型图片的加载崩溃，笔者没有测试过，如果出现了，有概率和这种问题差不多，应当去同类型的QImageIOHandler派生中去查找问题，如QPngHandler,QXpmHandler,QXbmHandler,QPpmHandler

（2）代码可使用最大图片

struct Q_GUI_EXPORT QImageData {        // internal image dataQImageData();~QImageData();static QImageData *create(const QSize &size, QImage::Format format);static QImageData *create(uchar *data, int w, int h,  int bpl, QImage::Format format, bool readOnly, QImageCleanupFunction cleanupFunction = 0, void *cleanupInfo = 0);QAtomicInt ref;int width;int height;int depth;qsizetype nbytes;               // number of bytes dataqreal devicePixelRatio;QVector<QRgb> colortable;uchar *data;QImage::Format format;qsizetype bytes_per_line;int ser_no;               // serial numberint detach_no;qreal  dpmx;                // dots per meter X (or 0)qreal  dpmy;                // dots per meter Y (or 0)QPoint  offset;           // offset in pixelsuint own_data : 1;uint ro_data : 1;uint has_alpha_clut : 1;uint is_cached : 1;uint is_locked : 1;QImageCleanupFunction cleanupFunction;void* cleanupInfo;bool checkForAlphaPixels() const;// Convert the image in-place, minimizing memory reallocation// Return false if the conversion cannot be done in-place.bool convertInPlace(QImage::Format newFormat, Qt::ImageConversionFlags);QMap<QString, QString> text;bool doImageIO(const QImage *image, QImageWriter* io, int quality) const;QPaintEngine *paintEngine;
};

这是 QImage 的实际存放数据的类，调用 create 函数时，实际申请内存的部分代码为:

QImageData * QImageData::create(const QSize &size, QImage::Format format)
{if (!size.isValid() || format == QImage::Format_Invalid)return 0;                                // invalid parameter(s)uint width = size.width();uint height = size.height();uint depth = qt_depthForFormat(format);const int bytes_per_line = ((width * depth + 31) >> 5) << 2; // bytes per scanline (must be multiple of 4)...d->bytes_per_line = bytes_per_line;d->nbytes = d->bytes_per_line*height;d->data  = (uchar *)malloc(d->nbytes);...
}

... 表示部分源码省略展示，可以看到 d->nbytes 为实际的可以申请的内存大小，其类型为 qsizetype nbytes; , 在 64 位系统上：qsizetype = long long, 所以不考虑电脑性能，实际可以申请和使用的最大的图片的容量为：

(2^63-1) / 1024 / 1024 / 1024 / 1024 ≈ 8388608 TB

可见，不考虑加载图片，仅是代码申请QImage情况下，可用性是够够的...

源代码

read_dib_body

static bool read_dib_body(QDataStream &s, const BMP_INFOHDR &bi, qint64 offset, qint64 startpos, QImage &image)
{QIODevice* d = s.device();if (d->atEnd())                                // end of stream/filereturn false;
#if 0qDebug("offset...........%lld", offset);qDebug("startpos.........%lld", startpos);qDebug("biSize...........%d", bi.biSize);qDebug("biWidth..........%d", bi.biWidth);qDebug("biHeight.........%d", bi.biHeight);qDebug("biPlanes.........%d", bi.biPlanes);qDebug("biBitCount.......%d", bi.biBitCount);qDebug("biCompression....%d", bi.biCompression);qDebug("biSizeImage......%d", bi.biSizeImage);qDebug("biXPelsPerMeter..%d", bi.biXPelsPerMeter);qDebug("biYPelsPerMeter..%d", bi.biYPelsPerMeter);qDebug("biClrUsed........%d", bi.biClrUsed);qDebug("biClrImportant...%d", bi.biClrImportant);
#endifint w = bi.biWidth,         h = bi.biHeight,  nbits = bi.biBitCount;int t = bi.biSize,         comp = bi.biCompression;uint red_mask = 0;uint green_mask = 0;uint blue_mask = 0;uint alpha_mask = 0;int red_shift = 0;int green_shift = 0;int blue_shift = 0;int alpha_shift = 0;int red_scale = 0;int green_scale = 0;int blue_scale = 0;int alpha_scale = 0;if (!d->isSequential())d->seek(startpos + BMP_FILEHDR_SIZE + bi.biSize); // goto start of colormap or masksif (bi.biSize >= BMP_WIN4) {red_mask = bi.biRedMask;green_mask = bi.biGreenMask;blue_mask = bi.biBlueMask;alpha_mask = bi.biAlphaMask;} else if (comp == BMP_BITFIELDS && (nbits == 16 || nbits == 32)) {if (d->read((char *)&red_mask, sizeof(red_mask)) != sizeof(red_mask))return false;if (d->read((char *)&green_mask, sizeof(green_mask)) != sizeof(green_mask))return false;if (d->read((char *)&blue_mask, sizeof(blue_mask)) != sizeof(blue_mask))return false;}bool transp = (comp == BMP_BITFIELDS) && alpha_mask;int ncols = 0;int depth = 0;QImage::Format format;switch (nbits) {case 32:case 24:case 16:depth = 32;format = transp ? QImage::Format_ARGB32 : QImage::Format_RGB32;break;case 8:case 4:depth = 8;format = QImage::Format_Indexed8;break;default:depth = 1;format = QImage::Format_Mono;}if (depth != 32) {ncols = bi.biClrUsed ? bi.biClrUsed : 1 << nbits;if (ncols < 1 || ncols > 256) // sanity check - don't run out of mem if color table is brokenreturn false;}if (bi.biHeight < 0)h = -h;                  // support images with negative heightif (image.size() != QSize(w, h) || image.format() != format) {image = QImage(w, h, format);if (image.isNull())                        // could not create imagereturn false;if (ncols)image.setColorCount(ncols);            // Ensure valid QImage}image.setDotsPerMeterX(bi.biXPelsPerMeter);image.setDotsPerMeterY(bi.biYPelsPerMeter);if (ncols > 0) {                                // read color tableimage.setColorCount(ncols);uchar rgb[4];int   rgb_len = t == BMP_OLD ? 3 : 4;for (int i=0; i<ncols; i++) {if (d->read((char *)rgb, rgb_len) != rgb_len)return false;image.setColor(i, qRgb(rgb[2],rgb[1],rgb[0]));if (d->atEnd())                        // truncated filereturn false;}} else if (comp == BMP_BITFIELDS && (nbits == 16 || nbits == 32)) {red_shift = calc_shift(red_mask);if (((red_mask >> red_shift) + 1) == 0)return false;red_scale = 256 / ((red_mask >> red_shift) + 1);green_shift = calc_shift(green_mask);if (((green_mask >> green_shift) + 1) == 0)return false;green_scale = 256 / ((green_mask >> green_shift) + 1);blue_shift = calc_shift(blue_mask);if (((blue_mask >> blue_shift) + 1) == 0)return false;blue_scale = 256 / ((blue_mask >> blue_shift) + 1);alpha_shift = calc_shift(alpha_mask);if (((alpha_mask >> alpha_shift) + 1) == 0)return false;alpha_scale = 256 / ((alpha_mask >> alpha_shift) + 1);} else if (comp == BMP_RGB && (nbits == 24 || nbits == 32)) {blue_mask = 0x000000ff;green_mask = 0x0000ff00;red_mask = 0x00ff0000;blue_shift = 0;green_shift = 8;red_shift = 16;blue_scale = green_scale = red_scale = 1;} else if (comp == BMP_RGB && nbits == 16) {blue_mask = 0x001f;green_mask = 0x03e0;red_mask = 0x7c00;blue_shift = 0;green_shift = 2;red_shift = 7;red_scale = 1;green_scale = 1;blue_scale = 8;}#if 0qDebug("Rmask: %08x Rshift: %08x Rscale:%08x", red_mask, red_shift, red_scale);qDebug("Gmask: %08x Gshift: %08x Gscale:%08x", green_mask, green_shift, green_scale);qDebug("Bmask: %08x Bshift: %08x Bscale:%08x", blue_mask, blue_shift, blue_scale);qDebug("Amask: %08x Ashift: %08x Ascale:%08x", alpha_mask, alpha_shift, alpha_scale);
#endif// offset can be bogus, be carefulif (offset>=0 && startpos + offset > d->pos()) {if (!d->isSequential())d->seek(startpos + offset);                // start of image data}qint64             bpl = image.bytesPerLine();uchar *data = image.bits();if (nbits == 1) {                                // 1 bit BMP imagewhile (--h >= 0) {if (d->read((char*)(data + h*bpl), bpl) != bpl)break;}if (ncols == 2 && qGray(image.color(0)) < qGray(image.color(1)))swapPixel01(&image);                // pixel 0 is white!}else if (nbits == 4) {                        // 4 bit BMP imageint    buflen = ((w+7)/8)*4;uchar *buf    = new uchar[buflen];if (comp == BMP_RLE4) {                // run length compressionint x=0, y=0, c, i;quint8 b;uchar *p = data + (h-1)*bpl;const uchar *endp = p + w;while (y < h) {if (!d->getChar((char *)&b))break;if (b == 0) {                        // escape codeif (!d->getChar((char *)&b) || b == 1) {y = h;                // exit loop} else switch (b) {case 0:                        // end of linex = 0;y++;p = data + (h-y-1)*bpl;break;case 2:                        // delta (jump){quint8 tmp;d->getChar((char *)&tmp);x += tmp;d->getChar((char *)&tmp);y += tmp;}// Protectionif ((uint)x >= (uint)w)x = w-1;if ((uint)y >= (uint)h)y = h-1;p = data + (h-y-1)*bpl + x;break;default:                // absolute mode// Protectionif (p + b > endp)b = endp-p;i = (c = b)/2;while (i--) {d->getChar((char *)&b);*p++ = b >> 4;*p++ = b & 0x0f;}if (c & 1) {unsigned char tmp;d->getChar((char *)&tmp);*p++ = tmp >> 4;}if ((((c & 3) + 1) & 2) == 2)d->getChar(0);        // align on word boundaryx += c;}} else {                        // encoded mode// Protectionif (p + b > endp)b = endp-p;i = (c = b)/2;d->getChar((char *)&b);                // 2 pixels to be repeatedwhile (i--) {*p++ = b >> 4;*p++ = b & 0x0f;}if (c & 1)*p++ = b >> 4;x += c;}}} else if (comp == BMP_RGB) {                // no compressionmemset(data, 0, h*bpl);while (--h >= 0) {if (d->read((char*)buf,buflen) != buflen)break;uchar *p = data + h*bpl;uchar *b = buf;for (int i=0; i<w/2; i++) {        // convert nibbles to bytes*p++ = *b >> 4;*p++ = *b++ & 0x0f;}if (w & 1)                        // the last nibble*p = *b >> 4;}}delete [] buf;}else if (nbits == 8) {                        // 8 bit BMP imageif (comp == BMP_RLE8) {                // run length compressionint x=0, y=0;quint8 b;uchar *p = data + (h-1)*bpl;const uchar *endp = p + w;while (y < h) {if (!d->getChar((char *)&b))break;if (b == 0) {                        // escape codeif (!d->getChar((char *)&b) || b == 1) {y = h;                // exit loop} else switch (b) {case 0:                        // end of linex = 0;y++;p = data + (h-y-1)*bpl;break;case 2:                        // delta (jump){quint8 tmp;d->getChar((char *)&tmp);x += tmp;d->getChar((char *)&tmp);y += tmp;}// Protectionif ((uint)x >= (uint)w)x = w-1;if ((uint)y >= (uint)h)y = h-1;p = data + (h-y-1)*bpl + x;break;default:                // absolute mode// Protectionif (p + b > endp)b = endp-p;if (d->read((char *)p, b) != b)return false;if ((b & 1) == 1)d->getChar(0);        // align on word boundaryx += b;p += b;}} else {                        // encoded mode// Protectionif (p + b > endp)b = endp-p;char tmp;d->getChar(&tmp);memset(p, tmp, b); // repeat pixelx += b;p += b;}}} else if (comp == BMP_RGB) {                // uncompressedwhile (--h >= 0) {if (d->read((char *)data + h*bpl, bpl) != bpl)break;}}}else if (nbits == 16 || nbits == 24 || nbits == 32) { // 16,24,32 bit BMP imageQRgb *p;QRgb  *end;uchar *buf24 = new uchar[bpl];int    bpl24 = ((w*nbits+31)/32)*4;uchar *b;int c;while (--h >= 0) {p = (QRgb *)(data + h*bpl);end = p + w;if (d->read((char *)buf24,bpl24) != bpl24)break;b = buf24;while (p < end) {c = *(uchar*)b | (*(uchar*)(b+1)<<8);if (nbits > 16)c |= *(uchar*)(b+2)<<16;if (nbits > 24)c |= *(uchar*)(b+3)<<24;*p++ = qRgba(((c & red_mask) >> red_shift) * red_scale,((c & green_mask) >> green_shift) * green_scale,((c & blue_mask) >> blue_shift) * blue_scale,transp ? ((c & alpha_mask) >> alpha_shift) * alpha_scale : 0xff);b += nbits/8;}}delete[] buf24;}if (bi.biHeight < 0) {// Flip the imageuchar *buf = new uchar[bpl];h = -bi.biHeight;for (int y = 0; y < h/2; ++y) {memcpy(buf, data + y*bpl, bpl);memcpy(data + y*bpl, data + (h-y-1)*bpl, bpl);memcpy(data + (h-y-1)*bpl, buf, bpl);}delete [] buf;}return true;
}