50 #include <QBuffer>

    51 #include <QImageReader>

    52 #include <private/qsimd_p.h>

   133 bool QRasterPixmapData::fromData(const uchar *buffer, uint len, const char *format,

   134                       Qt::ImageConversionFlags flags)

   135 {

   136     QByteArray a = QByteArray::fromRawData(reinterpret_cast<const char *>(buffer), len);

   137     QBuffer b(&a);

   138     b.open(QIODevice::ReadOnly);

   139     QImage image = QImageReader(&b, format).read();

   140     if (image.isNull())

   141         return false;

   142 

   143     createPixmapForImage(image, flags, /* inplace = */true);

   144     return !isNull();

   145 }

   146 

   168 

   169 void QRasterPixmapData::copy(const QPixmapData *data, const QRect &rect)

   170 {

   171     fromImage(data->toImage(rect).copy(), Qt::NoOpaqueDetection);

   172 }

   306 }

   307 

   308 QImage QRasterPixmapData::toImage(const QRect &rect) const

   309 {

   310     if (rect.isNull())

   311         return image;

   312 

   313     QRect clipped = rect.intersected(QRect(0, 0, w, h));

   314     if (d % 8 == 0)

   315         return QImage(image.scanLine(clipped.y()) + clipped.x() * (d / 8),

   316                       clipped.width(), clipped.height(),

   317                       image.bytesPerLine(), image.format());

   318     else

   319         return image.copy(clipped);

   369 void QRasterPixmapData::createPixmapForImage(QImage &sourceImage, Qt::ImageConversionFlags flags, bool inPlace)

   370 {

   371     QImage::Format format;

   372 #ifdef Q_WS_QWS

   373     if (pixelType() == BitmapType) {

   374         format = QImage::Format_Mono;

   375     } else {

   376         format = QScreen::instance()->pixelFormat();

   377         if (format == QImage::Format_Invalid)

   378             format = QImage::Format_ARGB32_Premultiplied;

   379         else if (format == QImage::Format_Indexed8) // currently not supported

   380             format = QImage::Format_RGB444;

   381     }

   382 

   383     if (sourceImage.hasAlphaChannel()

   384         && ((flags & Qt::NoOpaqueDetection)

   385             || const_cast<QImage &>(sourceImage).data_ptr()->checkForAlphaPixels())) {

   386         switch (format) {

   387             case QImage::Format_RGB16:

   388                 format = QImage::Format_ARGB8565_Premultiplied;

   389                 break;

   390             case QImage::Format_RGB666:

   391                 format = QImage::Format_ARGB6666_Premultiplied;

   392                 break;

   393             case QImage::Format_RGB555:

   394                 format = QImage::Format_ARGB8555_Premultiplied;

   395                 break;

   396             case QImage::Format_RGB444:

   397                 format = QImage::Format_ARGB4444_Premultiplied;

   398                 break;

   399             default:

   400                 format = QImage::Format_ARGB32_Premultiplied;

   401                 break;

   402         }

   403     } else if (format == QImage::Format_Invalid) {

   404         format = QImage::Format_ARGB32_Premultiplied;

   405     }

   406 #else

   407     if (pixelType() == BitmapType) {

   408         format = QImage::Format_MonoLSB;

   409     } else {

   410         if (sourceImage.depth() == 1) {

   411             format = sourceImage.hasAlphaChannel()

   412                     ? QImage::Format_ARGB32_Premultiplied

   413                     : QImage::Format_RGB32;

   414         } else {

   415             QImage::Format opaqueFormat = QNativeImage::systemFormat();

   416             QImage::Format alphaFormat = QImage::Format_ARGB32_Premultiplied;

   417 

   418 #if !defined(QT_HAVE_NEON) && !defined(QT_ALWAYS_HAVE_SSE2)

   419             switch (opaqueFormat) {

   420             case QImage::Format_RGB16:

   421                 alphaFormat = QImage::Format_ARGB8565_Premultiplied;

   422                 break;

   423             default: // We don't care about the others...

   424                 break;

   425             }

   426 #endif

   427 

   428             if (!sourceImage.hasAlphaChannel()) {

   429                 format = opaqueFormat;

   430             } else if ((flags & Qt::NoOpaqueDetection) == 0

   431                        && !const_cast<QImage &>(sourceImage).data_ptr()->checkForAlphaPixels())

   432             {

   433                 // image has alpha format but is really opaque, so try to do a

   434                 // more efficient conversion

   435                 if (sourceImage.format() == QImage::Format_ARGB32

   436                     || sourceImage.format() == QImage::Format_ARGB32_Premultiplied)

   437                 {

   438                     if (!inPlace)

   439                         sourceImage.detach();

   440                     sourceImage.d->format = QImage::Format_RGB32;

   441                 }

   442                 format = opaqueFormat;

   443             } else {

   444                 format = alphaFormat;

   445             }

   446         }

   447     }

   448 #endif

   449 

   450     if (inPlace && sourceImage.d->convertInPlace(format, flags)) {

   451         image = sourceImage;

   452     } else {

   453         image = sourceImage.convertToFormat(format);

   454     }

   455 

   456     if (image.d) {

   457         w = image.d->width;

   458         h = image.d->height;

   459         d = image.d->depth;

   460     } else {

   461         w = h = d = 0;

   462     }

   463     is_null = (w <= 0 || h <= 0);

   464 

   465     setSerialNumber(image.serialNumber());

   466 }

   467