diff options
Diffstat (limited to 'src/gui/painting')
94 files changed, 5374 insertions, 2097 deletions
diff --git a/src/gui/painting/qbackingstore.cpp b/src/gui/painting/qbackingstore.cpp index ecc0d1cac2..2304ee2256 100644 --- a/src/gui/painting/qbackingstore.cpp +++ b/src/gui/painting/qbackingstore.cpp @@ -25,11 +25,32 @@ public: { } + // Returns the DPR for the backing store. This is the DPR for the QWindow, + // possibly rounded up to the nearest integer. + qreal backingStoreDevicePixelRatio() const + { + // Note: keep in sync with QWidget::metric()! + qreal windowDpr = window->devicePixelRatio(); + return downscale ? std::ceil(windowDpr) : windowDpr; + } + + // Returns the factor used for converting from device independent to native + // backing store sizes. Normally this is just the gui scale factor, however + // if the backing store rounds the DPR up to the nearest integer then we also + // need to account for the factor introduced by that rounding. + qreal deviceIndependentToNativeFactor() const + { + const qreal roundingFactor = backingStoreDevicePixelRatio() / window->devicePixelRatio(); + const qreal guiFactor = QHighDpiScaling::factor(window); + return roundingFactor * guiFactor; + } + QWindow *window; QPlatformBackingStore *platformBackingStore = nullptr; QScopedPointer<QImage> highDpiBackingstore; QRegion staticContents; QSize size; + bool downscale = qEnvironmentVariableIntValue("QT_WIDGETS_HIGHDPI_DOWNSCALE") > 0; }; /*! @@ -94,12 +115,14 @@ QWindow* QBackingStore::window() const void QBackingStore::beginPaint(const QRegion ®ion) { + const qreal dpr = d_ptr->backingStoreDevicePixelRatio(); + if (d_ptr->highDpiBackingstore && - d_ptr->highDpiBackingstore->devicePixelRatio() != d_ptr->window->devicePixelRatio()) + d_ptr->highDpiBackingstore->devicePixelRatio() != dpr) resize(size()); QPlatformBackingStore *platformBackingStore = handle(); - platformBackingStore->beginPaint(QHighDpi::toNativeLocalRegion(region, d_ptr->window)); + platformBackingStore->beginPaint(QHighDpi::scale(region, d_ptr->deviceIndependentToNativeFactor())); // When QtGui is applying a high-dpi scale factor the backing store // creates a "large" backing store image. This image needs to be @@ -118,8 +141,7 @@ void QBackingStore::beginPaint(const QRegion ®ion) d_ptr->highDpiBackingstore.reset( new QImage(source->bits(), source->width(), source->height(), source->bytesPerLine(), source->format())); - qreal targetDevicePixelRatio = d_ptr->window->devicePixelRatio(); - d_ptr->highDpiBackingstore->setDevicePixelRatio(targetDevicePixelRatio); + d_ptr->highDpiBackingstore->setDevicePixelRatio(dpr); } } } @@ -184,13 +206,15 @@ void QBackingStore::flush(const QRegion ®ion, QWindow *window, const QPoint & Q_ASSERT(window == topLevelWindow || topLevelWindow->isAncestorOf(window, QWindow::ExcludeTransients)); - QRegion nativeRegion = QHighDpi::toNativeLocalRegion(region, window); + const qreal toNativeFactor = d_ptr->deviceIndependentToNativeFactor(); + + QRegion nativeRegion = QHighDpi::scale(region, toNativeFactor); QPoint nativeOffset; if (!offset.isNull()) { - nativeOffset = QHighDpi::toNativeLocalPosition(offset, window); + nativeOffset = QHighDpi::scale(offset, toNativeFactor); // Under fractional DPR, rounding of region and offset may accumulate to an off-by-one QPoint topLeft = region.boundingRect().topLeft() + offset; - QPoint nativeTopLeft = QHighDpi::toNativeLocalPosition(topLeft, window); + QPoint nativeTopLeft = QHighDpi::scale(topLeft, toNativeFactor); QPoint diff = nativeTopLeft - (nativeRegion.boundingRect().topLeft() + nativeOffset); Q_ASSERT(qMax(qAbs(diff.x()), qAbs(diff.y())) <= 1); nativeRegion.translate(diff); @@ -206,7 +230,8 @@ void QBackingStore::flush(const QRegion ®ion, QWindow *window, const QPoint & void QBackingStore::resize(const QSize &size) { d_ptr->size = size; - handle()->resize(QHighDpi::toNativePixels(size, d_ptr->window), d_ptr->staticContents); + const qreal factor = d_ptr->deviceIndependentToNativeFactor(); + handle()->resize(QHighDpi::scale(size, factor), QHighDpi::scale(d_ptr->staticContents, factor)); } /*! @@ -228,13 +253,13 @@ bool QBackingStore::scroll(const QRegion &area, int dx, int dy) // Disable scrolling for non-integer scroll deltas. For this case // the existing rendered pixels can't be re-used, and we return // false to signal that a repaint is needed. - const qreal nativeDx = QHighDpi::toNativePixels(qreal(dx), d_ptr->window); - const qreal nativeDy = QHighDpi::toNativePixels(qreal(dy), d_ptr->window); + const qreal toNativeFactor = d_ptr->deviceIndependentToNativeFactor(); + const qreal nativeDx = QHighDpi::scale(qreal(dx), toNativeFactor); + const qreal nativeDy = QHighDpi::scale(qreal(dy), toNativeFactor); if (qFloor(nativeDx) != nativeDx || qFloor(nativeDy) != nativeDy) return false; - return handle()->scroll(QHighDpi::toNativeLocalRegion(area, d_ptr->window), - nativeDx, nativeDy); + return handle()->scroll(QHighDpi::scale(area, toNativeFactor), nativeDx, nativeDy); } /*! @@ -242,6 +267,13 @@ bool QBackingStore::scroll(const QRegion &area, int dx, int dy) */ void QBackingStore::setStaticContents(const QRegion ®ion) { + [[maybe_unused]] static const bool didCheckPlatformSupport = []{ + const auto *integration = QGuiApplicationPrivate::platformIntegration(); + if (!integration->hasCapability(QPlatformIntegration::BackingStoreStaticContents)) + qWarning("QBackingStore::setStaticContents(): Platform does not support static contents"); + return true; + }(); + d_ptr->staticContents = region; } diff --git a/src/gui/painting/qbackingstoredefaultcompositor.cpp b/src/gui/painting/qbackingstoredefaultcompositor.cpp index c14efdd42e..c1452ca768 100644 --- a/src/gui/painting/qbackingstoredefaultcompositor.cpp +++ b/src/gui/painting/qbackingstoredefaultcompositor.cpp @@ -17,18 +17,14 @@ QBackingStoreDefaultCompositor::~QBackingStoreDefaultCompositor() void QBackingStoreDefaultCompositor::reset() { - delete m_psNoBlend; - m_psNoBlend = nullptr; - delete m_psBlend; - m_psBlend = nullptr; - delete m_psPremulBlend; - m_psPremulBlend = nullptr; - delete m_sampler; - m_sampler = nullptr; - delete m_vbuf; - m_vbuf = nullptr; - delete m_texture; - m_texture = nullptr; + m_rhi = nullptr; + m_psNoBlend.reset(); + m_psBlend.reset(); + m_psPremulBlend.reset(); + m_samplerNearest.reset(); + m_samplerLinear.reset(); + m_vbuf.reset(); + m_texture.reset(); m_widgetQuadData.reset(); for (PerQuadData &d : m_textureQuadData) d.reset(); @@ -71,9 +67,7 @@ QRhiTexture *QBackingStoreDefaultCompositor::toTexture(const QImage &sourceImage Q_FALLTHROUGH(); case QImage::Format_RGB32: case QImage::Format_ARGB32: -#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN *flags |= QPlatformBackingStore::TextureSwizzle; -#endif break; case QImage::Format_RGBA8888_Premultiplied: *flags |= QPlatformBackingStore::TexturePremultiplied; @@ -101,7 +95,7 @@ QRhiTexture *QBackingStoreDefaultCompositor::toTexture(const QImage &sourceImage const bool resized = !m_texture || m_texture->pixelSize() != image.size(); if (dirtyRegion.isEmpty() && !resized) - return m_texture; + return m_texture.get(); if (needsConversion) image = image.convertToFormat(QImage::Format_RGBA8888); @@ -110,11 +104,11 @@ QRhiTexture *QBackingStoreDefaultCompositor::toTexture(const QImage &sourceImage if (resized) { if (!m_texture) - m_texture = rhi->newTexture(QRhiTexture::RGBA8, image.size()); + m_texture.reset(rhi->newTexture(QRhiTexture::RGBA8, image.size())); else m_texture->setPixelSize(image.size()); m_texture->create(); - resourceUpdates->uploadTexture(m_texture, image); + resourceUpdates->uploadTexture(m_texture.get(), image); } else { QRect imageRect = image.rect(); QRect rect = dirtyRegion.boundingRect() & imageRect; @@ -123,35 +117,34 @@ QRhiTexture *QBackingStoreDefaultCompositor::toTexture(const QImage &sourceImage subresDesc.setSourceSize(rect.size()); subresDesc.setDestinationTopLeft(rect.topLeft()); QRhiTextureUploadDescription uploadDesc(QRhiTextureUploadEntry(0, 0, subresDesc)); - resourceUpdates->uploadTexture(m_texture, uploadDesc); + resourceUpdates->uploadTexture(m_texture.get(), uploadDesc); } - return m_texture; + return m_texture.get(); } -static inline QRect deviceRect(const QRect &rect, QWindow *window) +static inline QRect scaledRect(const QRect &rect, qreal factor) { - return QRect(rect.topLeft() * window->devicePixelRatio(), - rect.size() * window->devicePixelRatio()); + return QRect(rect.topLeft() * factor, rect.size() * factor); } -static inline QPoint deviceOffset(const QPoint &pt, QWindow *window) +static inline QPoint scaledOffset(const QPoint &pt, qreal factor) { - return pt * window->devicePixelRatio(); + return pt * factor; } -static QRegion deviceRegion(const QRegion ®ion, QWindow *window, const QPoint &offset) +static QRegion scaledRegion(const QRegion ®ion, qreal factor, const QPoint &offset) { - if (offset.isNull() && window->devicePixelRatio() <= 1) + if (offset.isNull() && factor <= 1) return region; QVarLengthArray<QRect, 4> rects; rects.reserve(region.rectCount()); for (const QRect &rect : region) - rects.append(deviceRect(rect.translated(offset), window)); + rects.append(scaledRect(rect.translated(offset), factor)); QRegion deviceRegion; - deviceRegion.setRects(rects.constData(), rects.count()); + deviceRegion.setRects(rects.constData(), rects.size()); return deviceRegion; } @@ -173,7 +166,7 @@ static QMatrix4x4 targetTransform(const QRectF &target, const QRect &viewport, b matrix(1,3) = y_translate; matrix(0,0) = x_scale; - matrix(1,1) = y_scale; + matrix(1,1) = (invertY ? -1.0 : 1.0) * y_scale; return matrix; } @@ -236,12 +229,12 @@ static bool prepareDrawForRenderToTextureWidget(const QPlatformTextureList *text const QRect clippedRectInWindow = rectInWindow & clipRect.translated(rectInWindow.topLeft()); const QRect srcRect = toBottomLeftRect(clipRect, rectInWindow.height()); - *target = targetTransform(deviceRect(clippedRectInWindow, window), + *target = targetTransform(scaledRect(clippedRectInWindow, window->devicePixelRatio()), deviceWindowRect, invertTargetY); - *source = sourceTransform(deviceRect(srcRect, window), - deviceRect(rectInWindow, window).size(), + *source = sourceTransform(scaledRect(srcRect, window->devicePixelRatio()), + scaledRect(rectInWindow, window->devicePixelRatio()).size(), invertSource ? SourceTransformOrigin::TopLeft : SourceTransformOrigin::BottomLeft); return true; @@ -282,7 +275,7 @@ enum class PipelineBlend { static QRhiGraphicsPipeline *createGraphicsPipeline(QRhi *rhi, QRhiShaderResourceBindings *srb, - QRhiSwapChain *swapchain, + QRhiRenderPassDescriptor *rpDesc, PipelineBlend blend) { QRhiGraphicsPipeline *ps = rhi->newGraphicsPipeline(); @@ -326,7 +319,7 @@ static QRhiGraphicsPipeline *createGraphicsPipeline(QRhi *rhi, }); ps->setVertexInputLayout(inputLayout); ps->setShaderResourceBindings(srb); - ps->setRenderPassDescriptor(swapchain->renderPassDescriptor()); + ps->setRenderPassDescriptor(rpDesc); if (!ps->create()) { qWarning("QBackingStoreDefaultCompositor: Failed to build graphics pipeline"); @@ -338,7 +331,7 @@ static QRhiGraphicsPipeline *createGraphicsPipeline(QRhi *rhi, static const int UBUF_SIZE = 120; -QBackingStoreDefaultCompositor::PerQuadData QBackingStoreDefaultCompositor::createPerQuadData(QRhiTexture *texture) +QBackingStoreDefaultCompositor::PerQuadData QBackingStoreDefaultCompositor::createPerQuadData(QRhiTexture *texture, QRhiTexture *textureExtra) { PerQuadData d; @@ -349,47 +342,72 @@ QBackingStoreDefaultCompositor::PerQuadData QBackingStoreDefaultCompositor::crea d.srb = m_rhi->newShaderResourceBindings(); d.srb->setBindings({ QRhiShaderResourceBinding::uniformBuffer(0, QRhiShaderResourceBinding::VertexStage | QRhiShaderResourceBinding::FragmentStage, d.ubuf, 0, UBUF_SIZE), - QRhiShaderResourceBinding::sampledTexture(1, QRhiShaderResourceBinding::FragmentStage, texture, m_sampler) + QRhiShaderResourceBinding::sampledTexture(1, QRhiShaderResourceBinding::FragmentStage, texture, m_samplerNearest.get()) }); if (!d.srb->create()) qWarning("QBackingStoreDefaultCompositor: Failed to create srb"); - d.lastUsedTexture = texture; + if (textureExtra) { + d.srbExtra = m_rhi->newShaderResourceBindings(); + d.srbExtra->setBindings({ + QRhiShaderResourceBinding::uniformBuffer(0, QRhiShaderResourceBinding::VertexStage | QRhiShaderResourceBinding::FragmentStage, d.ubuf, 0, UBUF_SIZE), + QRhiShaderResourceBinding::sampledTexture(1, QRhiShaderResourceBinding::FragmentStage, textureExtra, m_samplerNearest.get()) + }); + if (!d.srbExtra->create()) + qWarning("QBackingStoreDefaultCompositor: Failed to create srb"); + } + + d.lastUsedTextureExtra = textureExtra; + return d; } -void QBackingStoreDefaultCompositor::updatePerQuadData(PerQuadData *d, QRhiTexture *texture) +void QBackingStoreDefaultCompositor::updatePerQuadData(PerQuadData *d, QRhiTexture *texture, QRhiTexture *textureExtra, + UpdateQuadDataOptions options) { // This whole check-if-texture-ptr-is-different is needed because there is // nothing saying a QPlatformTextureList cannot return a different // QRhiTexture* from the same index in a subsequent flush. - if (d->lastUsedTexture == texture || !d->srb) + const QRhiSampler::Filter filter = options.testFlag(NeedsLinearFiltering) ? QRhiSampler::Linear : QRhiSampler::Nearest; + if ((d->lastUsedTexture == texture && d->lastUsedFilter == filter) || !d->srb) return; + QRhiSampler *sampler = filter == QRhiSampler::Linear ? m_samplerLinear.get() : m_samplerNearest.get(); d->srb->setBindings({ QRhiShaderResourceBinding::uniformBuffer(0, QRhiShaderResourceBinding::VertexStage | QRhiShaderResourceBinding::FragmentStage, d->ubuf, 0, UBUF_SIZE), - QRhiShaderResourceBinding::sampledTexture(1, QRhiShaderResourceBinding::FragmentStage, texture, m_sampler) + QRhiShaderResourceBinding::sampledTexture(1, QRhiShaderResourceBinding::FragmentStage, texture, sampler) }); d->srb->updateResources(QRhiShaderResourceBindings::BindingsAreSorted); - d->lastUsedTexture = texture; + d->lastUsedFilter = filter; + + if (textureExtra) { + d->srbExtra->setBindings({ + QRhiShaderResourceBinding::uniformBuffer(0, QRhiShaderResourceBinding::VertexStage | QRhiShaderResourceBinding::FragmentStage, d->ubuf, 0, UBUF_SIZE), + QRhiShaderResourceBinding::sampledTexture(1, QRhiShaderResourceBinding::FragmentStage, textureExtra, sampler) + }); + + d->srbExtra->updateResources(QRhiShaderResourceBindings::BindingsAreSorted); + d->lastUsedTextureExtra = textureExtra; + } } void QBackingStoreDefaultCompositor::updateUniforms(PerQuadData *d, QRhiResourceUpdateBatch *resourceUpdates, - const QMatrix4x4 &target, const QMatrix3x3 &source, bool needsRedBlueSwap) + const QMatrix4x4 &target, const QMatrix3x3 &source, + UpdateUniformOptions options) { resourceUpdates->updateDynamicBuffer(d->ubuf, 0, 64, target.constData()); updateMatrix3x3(resourceUpdates, d->ubuf, source); float opacity = 1.0f; resourceUpdates->updateDynamicBuffer(d->ubuf, 112, 4, &opacity); - qint32 swapRedBlue = needsRedBlueSwap ? 1 : 0; - resourceUpdates->updateDynamicBuffer(d->ubuf, 116, 4, &swapRedBlue); + qint32 textureSwizzle = options; + resourceUpdates->updateDynamicBuffer(d->ubuf, 116, 4, &textureSwizzle); } -void QBackingStoreDefaultCompositor::ensureResources(QRhiSwapChain *swapchain, QRhiResourceUpdateBatch *resourceUpdates) +void QBackingStoreDefaultCompositor::ensureResources(QRhiResourceUpdateBatch *resourceUpdates, QRhiRenderPassDescriptor *rpDesc) { static const float vertexData[] = { -1, -1, 0, 0, 0, @@ -401,41 +419,52 @@ void QBackingStoreDefaultCompositor::ensureResources(QRhiSwapChain *swapchain, Q }; if (!m_vbuf) { - m_vbuf = m_rhi->newBuffer(QRhiBuffer::Immutable, QRhiBuffer::VertexBuffer, sizeof(vertexData)); + m_vbuf.reset(m_rhi->newBuffer(QRhiBuffer::Immutable, QRhiBuffer::VertexBuffer, sizeof(vertexData))); if (m_vbuf->create()) - resourceUpdates->uploadStaticBuffer(m_vbuf, vertexData); + resourceUpdates->uploadStaticBuffer(m_vbuf.get(), vertexData); else qWarning("QBackingStoreDefaultCompositor: Failed to create vertex buffer"); } - if (!m_sampler) { - m_sampler = m_rhi->newSampler(QRhiSampler::Nearest, QRhiSampler::Nearest, QRhiSampler::None, - QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge); - if (!m_sampler->create()) - qWarning("QBackingStoreDefaultCompositor: Failed to create sampler"); + if (!m_samplerNearest) { + m_samplerNearest.reset(m_rhi->newSampler(QRhiSampler::Nearest, QRhiSampler::Nearest, QRhiSampler::None, + QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge)); + if (!m_samplerNearest->create()) + qWarning("QBackingStoreDefaultCompositor: Failed to create sampler (Nearest filtering)"); + } + + if (!m_samplerLinear) { + m_samplerLinear.reset(m_rhi->newSampler(QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None, + QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge)); + if (!m_samplerLinear->create()) + qWarning("QBackingStoreDefaultCompositor: Failed to create sampler (Linear filtering)"); } if (!m_widgetQuadData.isValid()) - m_widgetQuadData = createPerQuadData(m_texture); + m_widgetQuadData = createPerQuadData(m_texture.get()); QRhiShaderResourceBindings *srb = m_widgetQuadData.srb; // just for the layout if (!m_psNoBlend) - m_psNoBlend = createGraphicsPipeline(m_rhi, srb, swapchain, PipelineBlend::None); + m_psNoBlend.reset(createGraphicsPipeline(m_rhi, srb, rpDesc, PipelineBlend::None)); if (!m_psBlend) - m_psBlend = createGraphicsPipeline(m_rhi, srb, swapchain, PipelineBlend::Alpha); + m_psBlend.reset(createGraphicsPipeline(m_rhi, srb, rpDesc, PipelineBlend::Alpha)); if (!m_psPremulBlend) - m_psPremulBlend = createGraphicsPipeline(m_rhi, srb, swapchain, PipelineBlend::PremulAlpha); + m_psPremulBlend.reset(createGraphicsPipeline(m_rhi, srb, rpDesc, PipelineBlend::PremulAlpha)); } QPlatformBackingStore::FlushResult QBackingStoreDefaultCompositor::flush(QPlatformBackingStore *backingStore, QRhi *rhi, QRhiSwapChain *swapchain, QWindow *window, + qreal sourceDevicePixelRatio, const QRegion ®ion, const QPoint &offset, QPlatformTextureList *textures, bool translucentBackground) { + if (!rhi) + return QPlatformBackingStore::FlushFailed; + Q_ASSERT(textures); // may be empty if there are no render-to-texture widgets at all, but null it cannot be if (!m_rhi) { @@ -479,7 +508,7 @@ QPlatformBackingStore::FlushResult QBackingStoreDefaultCompositor::flush(QPlatfo const QImage::Format format = QImage::toImageFormat(graphicsBuffer->format()); const QSize size = graphicsBuffer->size(); QImage wrapperImage(graphicsBuffer->data(), size.width(), size.height(), graphicsBuffer->bytesPerLine(), format); - toTexture(wrapperImage, rhi, resourceUpdates, deviceRegion(region, window, offset), &flags); + toTexture(wrapperImage, rhi, resourceUpdates, scaledRegion(region, sourceDevicePixelRatio, offset), &flags); gotTextureFromGraphicsBuffer = true; graphicsBuffer->unlock(); if (graphicsBuffer->origin() == QPlatformGraphicsBuffer::OriginBottomLeft) @@ -487,34 +516,52 @@ QPlatformBackingStore::FlushResult QBackingStoreDefaultCompositor::flush(QPlatfo } } if (!gotTextureFromGraphicsBuffer) - toTexture(backingStore, rhi, resourceUpdates, deviceRegion(region, window, offset), &flags); + toTexture(backingStore, rhi, resourceUpdates, scaledRegion(region, sourceDevicePixelRatio, offset), &flags); - ensureResources(swapchain, resourceUpdates); + ensureResources(resourceUpdates, swapchain->renderPassDescriptor()); - const bool needsRedBlueSwap = (flags & QPlatformBackingStore::TextureSwizzle) != 0; + UpdateUniformOptions uniformOptions; +#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN + if (flags & QPlatformBackingStore::TextureSwizzle) + uniformOptions |= NeedsRedBlueSwap; +#else + if (flags & QPlatformBackingStore::TextureSwizzle) + uniformOptions |= NeedsAlphaRotate; +#endif const bool premultiplied = (flags & QPlatformBackingStore::TexturePremultiplied) != 0; SourceTransformOrigin origin = SourceTransformOrigin::TopLeft; if (flags & QPlatformBackingStore::TextureFlip) origin = SourceTransformOrigin::BottomLeft; - const QRect deviceWindowRect = deviceRect(QRect(QPoint(), window->size()), window); - const QPoint deviceWindowOffset = deviceOffset(offset, window); + const qreal dpr = window->devicePixelRatio(); + const QRect deviceWindowRect = scaledRect(QRect(QPoint(), window->size()), dpr); + const QRect sourceWindowRect = scaledRect(QRect(QPoint(), window->size()), sourceDevicePixelRatio); + // If sourceWindowRect is larger than deviceWindowRect, we are doing high + // DPI downscaling. In that case Linear filtering is a must, whereas for the + // 1:1 case Nearest must be used for Qt 5 visual compatibility. + const bool needsLinearSampler = sourceWindowRect.width() > deviceWindowRect.width() + && sourceWindowRect.height() > deviceWindowRect.height(); + + const bool invertTargetY = !rhi->isYUpInNDC(); + const bool invertSource = !rhi->isYUpInFramebuffer(); - const bool invertTargetY = rhi->clipSpaceCorrMatrix().data()[5] < 0.0f; - const bool invertSource = rhi->isYUpInFramebuffer() != rhi->isYUpInNDC(); if (m_texture) { - // The backingstore is for the entire tlw. - // In case of native children offset tells the position relative to the tlw. - const QRect srcRect = toBottomLeftRect(deviceWindowRect.translated(deviceWindowOffset), m_texture->pixelSize().height()); + // The backingstore is for the entire tlw. In case of native children, offset tells the position + // relative to the tlw. The window rect is scaled by the source device pixel ratio to get + // the source rect. + const QPoint sourceWindowOffset = scaledOffset(offset, sourceDevicePixelRatio); + const QRect srcRect = toBottomLeftRect(sourceWindowRect.translated(sourceWindowOffset), m_texture->pixelSize().height()); const QMatrix3x3 source = sourceTransform(srcRect, m_texture->pixelSize(), origin); QMatrix4x4 target; // identity if (invertTargetY) target.data()[5] = -1.0f; - updateUniforms(&m_widgetQuadData, resourceUpdates, target, source, needsRedBlueSwap); + updateUniforms(&m_widgetQuadData, resourceUpdates, target, source, uniformOptions); + if (needsLinearSampler) + updatePerQuadData(&m_widgetQuadData, m_texture.get(), nullptr, NeedsLinearFiltering); } const int textureWidgetCount = textures->count(); - const int oldTextureQuadDataCount = m_textureQuadData.count(); + const int oldTextureQuadDataCount = m_textureQuadData.size(); if (oldTextureQuadDataCount != textureWidgetCount) { for (int i = textureWidgetCount; i < oldTextureQuadDataCount; ++i) m_textureQuadData[i].reset(); @@ -522,21 +569,27 @@ QPlatformBackingStore::FlushResult QBackingStoreDefaultCompositor::flush(QPlatfo } for (int i = 0; i < textureWidgetCount; ++i) { + const bool invertSourceForTextureWidget = textures->flags(i).testFlag(QPlatformTextureList::MirrorVertically) + ? !invertSource : invertSource; QMatrix4x4 target; QMatrix3x3 source; if (!prepareDrawForRenderToTextureWidget(textures, i, window, deviceWindowRect, - offset, invertTargetY, invertSource, &target, &source)) + offset, invertTargetY, invertSourceForTextureWidget, + &target, &source)) { m_textureQuadData[i].reset(); continue; } QRhiTexture *t = textures->texture(i); + QRhiTexture *tExtra = textures->textureExtra(i); if (t) { if (!m_textureQuadData[i].isValid()) - m_textureQuadData[i] = createPerQuadData(t); + m_textureQuadData[i] = createPerQuadData(t, tExtra); else - updatePerQuadData(&m_textureQuadData[i], t); - updateUniforms(&m_textureQuadData[i], resourceUpdates, target, source, false); + updatePerQuadData(&m_textureQuadData[i], t, tExtra); + updateUniforms(&m_textureQuadData[i], resourceUpdates, target, source); + if (needsLinearSampler) + updatePerQuadData(&m_textureQuadData[i], t, tExtra, NeedsLinearFiltering); } else { m_textureQuadData[i].reset(); } @@ -546,47 +599,74 @@ QPlatformBackingStore::FlushResult QBackingStoreDefaultCompositor::flush(QPlatfo QRhiCommandBuffer *cb = swapchain->currentFrameCommandBuffer(); const QSize outputSizeInPixels = swapchain->currentPixelSize(); QColor clearColor = translucentBackground ? Qt::transparent : Qt::black; - cb->beginPass(swapchain->currentFrameRenderTarget(), clearColor, { 1.0f, 0 }, resourceUpdates); - cb->setGraphicsPipeline(m_psNoBlend); - cb->setViewport({ 0, 0, float(outputSizeInPixels.width()), float(outputSizeInPixels.height()) }); - QRhiCommandBuffer::VertexInput vbufBinding(m_vbuf, 0); - cb->setVertexInput(0, 1, &vbufBinding); + cb->resourceUpdate(resourceUpdates); - // Textures for renderToTexture widgets. - for (int i = 0; i < textureWidgetCount; ++i) { - if (!textures->flags(i).testFlag(QPlatformTextureList::StacksOnTop)) { - if (m_textureQuadData[i].isValid()) { - cb->setShaderResources(m_textureQuadData[i].srb); - cb->draw(6); + auto render = [&](std::optional<QRhiSwapChain::StereoTargetBuffer> buffer = std::nullopt) { + QRhiRenderTarget* target = nullptr; + if (buffer.has_value()) + target = swapchain->currentFrameRenderTarget(buffer.value()); + else + target = swapchain->currentFrameRenderTarget(); + + cb->beginPass(target, clearColor, { 1.0f, 0 }); + + cb->setGraphicsPipeline(m_psNoBlend.get()); + cb->setViewport({ 0, 0, float(outputSizeInPixels.width()), float(outputSizeInPixels.height()) }); + QRhiCommandBuffer::VertexInput vbufBinding(m_vbuf.get(), 0); + cb->setVertexInput(0, 1, &vbufBinding); + + // Textures for renderToTexture widgets. + for (int i = 0; i < textureWidgetCount; ++i) { + if (!textures->flags(i).testFlag(QPlatformTextureList::StacksOnTop)) { + if (m_textureQuadData[i].isValid()) { + + QRhiShaderResourceBindings* srb = m_textureQuadData[i].srb; + if (buffer == QRhiSwapChain::RightBuffer && m_textureQuadData[i].srbExtra) + srb = m_textureQuadData[i].srbExtra; + + cb->setShaderResources(srb); + cb->draw(6); + } } } - } - cb->setGraphicsPipeline(premultiplied ? m_psPremulBlend : m_psBlend); + cb->setGraphicsPipeline(premultiplied ? m_psPremulBlend.get() : m_psBlend.get()); - // Backingstore texture with the normal widgets. - if (m_texture) { - cb->setShaderResources(m_widgetQuadData.srb); - cb->draw(6); - } + // Backingstore texture with the normal widgets. + if (m_texture) { + cb->setShaderResources(m_widgetQuadData.srb); + cb->draw(6); + } - // Textures for renderToTexture widgets that have WA_AlwaysStackOnTop set. - for (int i = 0; i < textureWidgetCount; ++i) { - const QPlatformTextureList::Flags flags = textures->flags(i); - if (flags.testFlag(QPlatformTextureList::StacksOnTop)) { - if (m_textureQuadData[i].isValid()) { - if (flags.testFlag(QPlatformTextureList::NeedsPremultipliedAlphaBlending)) - cb->setGraphicsPipeline(m_psPremulBlend); - else - cb->setGraphicsPipeline(m_psBlend); - cb->setShaderResources(m_textureQuadData[i].srb); - cb->draw(6); + // Textures for renderToTexture widgets that have WA_AlwaysStackOnTop set. + for (int i = 0; i < textureWidgetCount; ++i) { + const QPlatformTextureList::Flags flags = textures->flags(i); + if (flags.testFlag(QPlatformTextureList::StacksOnTop)) { + if (m_textureQuadData[i].isValid()) { + if (flags.testFlag(QPlatformTextureList::NeedsPremultipliedAlphaBlending)) + cb->setGraphicsPipeline(m_psPremulBlend.get()); + else + cb->setGraphicsPipeline(m_psBlend.get()); + + QRhiShaderResourceBindings* srb = m_textureQuadData[i].srb; + if (buffer == QRhiSwapChain::RightBuffer && m_textureQuadData[i].srbExtra) + srb = m_textureQuadData[i].srbExtra; + + cb->setShaderResources(srb); + cb->draw(6); + } } } - } - cb->endPass(); + cb->endPass(); + }; + + if (swapchain->window()->format().stereo()) { + render(QRhiSwapChain::LeftBuffer); + render(QRhiSwapChain::RightBuffer); + } else + render(); rhi->endFrame(swapchain); diff --git a/src/gui/painting/qbackingstoredefaultcompositor_p.h b/src/gui/painting/qbackingstoredefaultcompositor_p.h index 5086638d2f..c5a8ffd328 100644 --- a/src/gui/painting/qbackingstoredefaultcompositor_p.h +++ b/src/gui/painting/qbackingstoredefaultcompositor_p.h @@ -16,7 +16,7 @@ // #include <qpa/qplatformbackingstore.h> -#include <QtGui/private/qrhi_p.h> +#include <rhi/qrhi.h> QT_BEGIN_NAMESPACE @@ -37,13 +37,24 @@ public: QRhi *rhi, QRhiSwapChain *swapchain, QWindow *window, + qreal sourceDevicePixelRatio, const QRegion ®ion, const QPoint &offset, QPlatformTextureList *textures, bool translucentBackground); private: - void ensureResources(QRhiSwapChain *swapchain, QRhiResourceUpdateBatch *resourceUpdates); + enum UpdateUniformOption { + NeedsRedBlueSwap = 1 << 0, + NeedsAlphaRotate = 1 << 1 + }; + Q_DECLARE_FLAGS(UpdateUniformOptions, UpdateUniformOption) + enum UpdateQuadDataOption { + NeedsLinearFiltering = 1 << 0 + }; + Q_DECLARE_FLAGS(UpdateQuadDataOptions, UpdateQuadDataOption) + + void ensureResources(QRhiResourceUpdateBatch *resourceUpdates, QRhiRenderPassDescriptor *rpDesc); QRhiTexture *toTexture(const QImage &image, QRhi *rhi, QRhiResourceUpdateBatch *resourceUpdates, @@ -51,35 +62,47 @@ private: QPlatformBackingStore::TextureFlags *flags) const; mutable QRhi *m_rhi = nullptr; - mutable QRhiTexture *m_texture = nullptr; + mutable std::unique_ptr<QRhiTexture> m_texture; - QRhiBuffer *m_vbuf = nullptr; - QRhiSampler *m_sampler = nullptr; - QRhiGraphicsPipeline *m_psNoBlend = nullptr; - QRhiGraphicsPipeline *m_psBlend = nullptr; - QRhiGraphicsPipeline *m_psPremulBlend = nullptr; + std::unique_ptr<QRhiBuffer> m_vbuf; + std::unique_ptr<QRhiSampler> m_samplerNearest; + std::unique_ptr<QRhiSampler> m_samplerLinear; + std::unique_ptr<QRhiGraphicsPipeline> m_psNoBlend; + std::unique_ptr<QRhiGraphicsPipeline> m_psBlend; + std::unique_ptr<QRhiGraphicsPipeline> m_psPremulBlend; struct PerQuadData { QRhiBuffer *ubuf = nullptr; // All srbs are layout-compatible. QRhiShaderResourceBindings *srb = nullptr; + QRhiShaderResourceBindings *srbExtra = nullptr; // may be null (used for stereo) QRhiTexture *lastUsedTexture = nullptr; + QRhiTexture *lastUsedTextureExtra = nullptr; // may be null (used for stereo) + QRhiSampler::Filter lastUsedFilter = QRhiSampler::None; bool isValid() const { return ubuf && srb; } void reset() { delete ubuf; ubuf = nullptr; delete srb; srb = nullptr; + if (srbExtra) { + delete srbExtra; + srbExtra = nullptr; + } lastUsedTexture = nullptr; + lastUsedTextureExtra = nullptr; + lastUsedFilter = QRhiSampler::None; } }; PerQuadData m_widgetQuadData; QVarLengthArray<PerQuadData, 8> m_textureQuadData; - PerQuadData createPerQuadData(QRhiTexture *texture); - void updatePerQuadData(PerQuadData *d, QRhiTexture *texture); + PerQuadData createPerQuadData(QRhiTexture *texture, QRhiTexture *textureExtra = nullptr); + void updatePerQuadData(PerQuadData *d, QRhiTexture *texture, QRhiTexture *textureExtra = nullptr, + UpdateQuadDataOptions options = {}); void updateUniforms(PerQuadData *d, QRhiResourceUpdateBatch *resourceUpdates, - const QMatrix4x4 &target, const QMatrix3x3 &source, bool needsRedBlueSwap); + const QMatrix4x4 &target, const QMatrix3x3 &source, + UpdateUniformOptions options = {}); }; QT_END_NAMESPACE diff --git a/src/gui/painting/qbackingstorerhisupport.cpp b/src/gui/painting/qbackingstorerhisupport.cpp index 81b3f0eb7d..fe5589dc2d 100644 --- a/src/gui/painting/qbackingstorerhisupport.cpp +++ b/src/gui/painting/qbackingstorerhisupport.cpp @@ -8,19 +8,9 @@ #if QT_CONFIG(opengl) #include <QtGui/qoffscreensurface.h> #include <QtGui/private/qopenglcontext_p.h> -#include <QtGui/private/qrhigles2_p.h> -#endif - -#ifdef Q_OS_WIN -#include <QtGui/private/qrhid3d11_p.h> -#endif - -#if defined(Q_OS_MACOS) || defined(Q_OS_IOS) -#include <QtGui/private/qrhimetal_p.h> #endif #if QT_CONFIG(vulkan) -#include <QtGui/private/qrhivulkan_p.h> #include <QtGui/private/qvulkandefaultinstance_p.h> #endif @@ -66,6 +56,19 @@ bool QBackingStoreRhiSupport::create() QOffscreenSurface *surface = nullptr; QRhi::Flags flags; + // These must be the same env.vars Qt Quick uses (as documented), in order + // to ensure symmetry in the behavior between a QQuickWindow and a + // (QRhi-based) widget top-level window. + if (qEnvironmentVariableIntValue("QSG_RHI_PREFER_SOFTWARE_RENDERER")) + flags |= QRhi::PreferSoftwareRenderer; + if (qEnvironmentVariableIntValue("QSG_RHI_PROFILE")) + flags |= QRhi::EnableDebugMarkers | QRhi::EnableTimestamps; + + if (m_config.api() == QPlatformBackingStoreRhiConfig::Null) { + QRhiNullInitParams params; + rhi = QRhi::create(QRhi::Null, ¶ms, flags); + } + #if QT_CONFIG(opengl) if (!rhi && m_config.api() == QPlatformBackingStoreRhiConfig::OpenGL) { surface = QRhiGles2InitParams::newFallbackSurface(m_format); @@ -79,14 +82,32 @@ bool QBackingStoreRhiSupport::create() #endif #ifdef Q_OS_WIN - if (!rhi && m_config.api() == QPlatformBackingStoreRhiConfig::D3D11) { - QRhiD3D11InitParams params; - params.enableDebugLayer = m_config.isDebugLayerEnabled(); - rhi = QRhi::create(QRhi::D3D11, ¶ms, flags); + if (!rhi) { + if (m_config.api() == QPlatformBackingStoreRhiConfig::D3D11) { + QRhiD3D11InitParams params; + params.enableDebugLayer = m_config.isDebugLayerEnabled(); + rhi = QRhi::create(QRhi::D3D11, ¶ms, flags); + if (!rhi && !flags.testFlag(QRhi::PreferSoftwareRenderer)) { + qCDebug(lcQpaBackingStore, "Failed to create a D3D11 device with default settings; " + "attempting to get a software rasterizer backed device instead"); + flags |= QRhi::PreferSoftwareRenderer; + rhi = QRhi::create(QRhi::D3D11, ¶ms, flags); + } + } else if (m_config.api() == QPlatformBackingStoreRhiConfig::D3D12) { + QRhiD3D12InitParams params; + params.enableDebugLayer = m_config.isDebugLayerEnabled(); + rhi = QRhi::create(QRhi::D3D12, ¶ms, flags); + if (!rhi && !flags.testFlag(QRhi::PreferSoftwareRenderer)) { + qCDebug(lcQpaBackingStore, "Failed to create a D3D12 device with default settings; " + "attempting to get a software rasterizer backed device instead"); + flags |= QRhi::PreferSoftwareRenderer; + rhi = QRhi::create(QRhi::D3D12, ¶ms, flags); + } + } } #endif -#if defined(Q_OS_MACOS) || defined(Q_OS_IOS) +#if QT_CONFIG(metal) if (!rhi && m_config.api() == QPlatformBackingStoreRhiConfig::Metal) { QRhiMetalInitParams params; // For parity with Qt Quick, fall back to OpenGL when there is no Metal (f.ex. in macOS virtual machines). @@ -116,7 +137,6 @@ bool QBackingStoreRhiSupport::create() return false; } params.window = m_window; - params.deviceExtensions = m_config.deviceExtensions(); rhi = QRhi::create(QRhi::Vulkan, ¶ms, flags); } #endif @@ -176,13 +196,14 @@ QRhiSwapChain *QBackingStoreRhiSupport::swapChainForWindow(QWindow *window) bool QBackingStoreRhiSupportWindowWatcher::eventFilter(QObject *obj, QEvent *event) { - if (event->type() == QEvent::PlatformSurface - && static_cast<QPlatformSurfaceEvent *>(event)->surfaceEventType() == QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed) + if (event->type() == QEvent::WindowAboutToChangeInternal + || (event->type() == QEvent::PlatformSurface + && static_cast<QPlatformSurfaceEvent *>(event)->surfaceEventType() == QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed)) { QWindow *window = qobject_cast<QWindow *>(obj); auto it = m_rhiSupport->m_swapchains.find(window); if (it != m_rhiSupport->m_swapchains.end()) { - qCDebug(lcQpaBackingStore) << "SurfaceAboutToBeDestroyed received for tracked window" << window << "cleaning up swapchain"; + qCDebug(lcQpaBackingStore) << event << "received for" << window << "- cleaning up swapchain"; auto data = *it; m_rhiSupport->m_swapchains.erase(it); data.reset(); // deletes 'this' @@ -196,6 +217,7 @@ QSurface::SurfaceType QBackingStoreRhiSupport::surfaceTypeForConfig(const QPlatf QSurface::SurfaceType type = QSurface::RasterSurface; switch (config.api()) { case QPlatformBackingStoreRhiConfig::D3D11: + case QPlatformBackingStoreRhiConfig::D3D12: type = QSurface::Direct3DSurface; break; case QPlatformBackingStoreRhiConfig::Vulkan: @@ -224,6 +246,8 @@ QRhi::Implementation QBackingStoreRhiSupport::apiToRhiBackend(QPlatformBackingSt return QRhi::Vulkan; case QPlatformBackingStoreRhiConfig::D3D11: return QRhi::D3D11; + case QPlatformBackingStoreRhiConfig::D3D12: + return QRhi::D3D12; case QPlatformBackingStoreRhiConfig::Null: return QRhi::Null; default: @@ -232,25 +256,6 @@ QRhi::Implementation QBackingStoreRhiSupport::apiToRhiBackend(QPlatformBackingSt return QRhi::Null; } -const char *QBackingStoreRhiSupport::apiName(QPlatformBackingStoreRhiConfig::Api api) -{ - switch (api) { - case QPlatformBackingStoreRhiConfig::OpenGL: - return "OpenGL"; - case QPlatformBackingStoreRhiConfig::Metal: - return "Metal"; - case QPlatformBackingStoreRhiConfig::Vulkan: - return "Vulkan"; - case QPlatformBackingStoreRhiConfig::D3D11: - return "D3D11"; - case QPlatformBackingStoreRhiConfig::Null: - return "Null"; - default: - break; - } - return "Unknown"; -} - bool QBackingStoreRhiSupport::checkForceRhi(QPlatformBackingStoreRhiConfig *outConfig, QSurface::SurfaceType *outType) { static QPlatformBackingStoreRhiConfig config; @@ -267,7 +272,7 @@ bool QBackingStoreRhiSupport::checkForceRhi(QPlatformBackingStoreRhiConfig *outC if (config.isEnabled()) { #if defined(Q_OS_WIN) config.setApi(QPlatformBackingStoreRhiConfig::D3D11); -#elif defined(Q_OS_MACOS) || defined(Q_OS_IOS) +#elif QT_CONFIG(metal) config.setApi(QPlatformBackingStoreRhiConfig::Metal); #elif QT_CONFIG(opengl) config.setApi(QPlatformBackingStoreRhiConfig::OpenGL); @@ -284,8 +289,10 @@ bool QBackingStoreRhiSupport::checkForceRhi(QPlatformBackingStoreRhiConfig *outC #ifdef Q_OS_WIN if (backend == QStringLiteral("d3d11") || backend == QStringLiteral("d3d")) config.setApi(QPlatformBackingStoreRhiConfig::D3D11); + if (backend == QStringLiteral("d3d12")) + config.setApi(QPlatformBackingStoreRhiConfig::D3D12); #endif -#if defined(Q_OS_MACOS) || defined(Q_OS_IOS) +#if QT_CONFIG(metal) if (backend == QStringLiteral("metal")) config.setApi(QPlatformBackingStoreRhiConfig::Metal); #endif @@ -304,7 +311,7 @@ bool QBackingStoreRhiSupport::checkForceRhi(QPlatformBackingStoreRhiConfig *outC } qCDebug(lcQpaBackingStore) << "Check for forced use of QRhi resulted in enable" - << config.isEnabled() << "with api" << apiName(config.api()); + << config.isEnabled() << "with api" << QRhi::backendName(apiToRhiBackend(config.api())); } if (config.isEnabled()) { diff --git a/src/gui/painting/qbackingstorerhisupport_p.h b/src/gui/painting/qbackingstorerhisupport_p.h index c67ea6dd6a..39ce36c680 100644 --- a/src/gui/painting/qbackingstorerhisupport_p.h +++ b/src/gui/painting/qbackingstorerhisupport_p.h @@ -19,7 +19,7 @@ #include <QtGui/qwindow.h> #include <QtGui/qsurfaceformat.h> #include <QtGui/qoffscreensurface.h> -#include <QtGui/private/qrhi_p.h> +#include <rhi/qrhi.h> #include <qpa/qplatformbackingstore.h> QT_BEGIN_NAMESPACE @@ -44,7 +44,6 @@ public: static bool checkForceRhi(QPlatformBackingStoreRhiConfig *outConfig, QSurface::SurfaceType *outType); static QRhi::Implementation apiToRhiBackend(QPlatformBackingStoreRhiConfig::Api api); - static const char *apiName(QPlatformBackingStoreRhiConfig::Api api); QRhi *rhi() const { return m_rhi; } diff --git a/src/gui/painting/qbezier_p.h b/src/gui/painting/qbezier_p.h index 373a35b2be..6c39dd55f9 100644 --- a/src/gui/painting/qbezier_p.h +++ b/src/gui/painting/qbezier_p.h @@ -18,7 +18,6 @@ #include <QtGui/private/qtguiglobal_p.h> #include "QtCore/qline.h" #include "QtCore/qlist.h" -#include "QtCore/qpair.h" #include "QtCore/qpoint.h" #include "QtCore/qrect.h" #include "QtGui/qtransform.h" diff --git a/src/gui/painting/qblendfunctions.cpp b/src/gui/painting/qblendfunctions.cpp index 2a51d06204..fa9f89262c 100644 --- a/src/gui/painting/qblendfunctions.cpp +++ b/src/gui/painting/qblendfunctions.cpp @@ -152,7 +152,7 @@ void qt_blend_rgb16_on_rgb16(uchar *dst, int dbpl, if (const_alpha == 256) { int length = w << 1; - while (h--) { + while (--h >= 0) { memcpy(dst, src, length); dst += dbpl; src += sbpl; @@ -162,7 +162,7 @@ void qt_blend_rgb16_on_rgb16(uchar *dst, int dbpl, const quint16 *s = (const quint16 *) src; quint8 a = (255 * const_alpha) >> 8; quint8 ia = 255 - a; - while (h--) { + while (--h >= 0) { for (int x=0; x<w; ++x) { d[x] = BYTE_MUL_RGB16(s[x], a) + BYTE_MUL_RGB16(d[x], ia); } diff --git a/src/gui/painting/qblendfunctions_p.h b/src/gui/painting/qblendfunctions_p.h index 90a7dbcf64..2f5ed36c73 100644 --- a/src/gui/painting/qblendfunctions_p.h +++ b/src/gui/painting/qblendfunctions_p.h @@ -89,7 +89,7 @@ void qt_scale_image_16bit(uchar *destPixels, int dbpl, if (xend < 0 || xend >= (int)(sbpl/sizeof(SRC))) --w; - while (h--) { + while (--h >= 0) { const SRC *src = (const SRC *) (srcPixels + (srcy >> 16) * sbpl); quint32 srcx = basex; int x = 0; @@ -180,7 +180,7 @@ template <typename T> void qt_scale_image_32bit(uchar *destPixels, int dbpl, if (xend < 0 || xend >= (int)(sbpl/sizeof(quint32))) --w; - while (h--) { + while (--h >= 0) { const uint *src = (const quint32 *) (srcPixels + (srcy >> 16) * sbpl); quint32 srcx = basex; int x = 0; diff --git a/src/gui/painting/qbrush.cpp b/src/gui/painting/qbrush.cpp index c195dc0553..b053896233 100644 --- a/src/gui/painting/qbrush.cpp +++ b/src/gui/painting/qbrush.cpp @@ -18,6 +18,7 @@ #include <QtCore/qnumeric.h> #include <QtCore/qfile.h> #include <QtCore/qmutex.h> +#include <QtCore/private/qoffsetstringarray_p.h> QT_BEGIN_NAMESPACE @@ -951,7 +952,7 @@ bool QBrush::operator==(const QBrush &b) const */ QDebug operator<<(QDebug dbg, const QBrush &b) { - static const char BRUSH_STYLES[][24] = { + static constexpr auto BRUSH_STYLES = qOffsetStringArray( "NoBrush", "SolidPattern", "Dense1Pattern", @@ -972,7 +973,7 @@ QDebug operator<<(QDebug dbg, const QBrush &b) "ConicalGradientPattern", "", "", "", "", "", "", "TexturePattern" // 24 - }; + ); QDebugStateSaver saver(dbg); dbg.nospace() << "QBrush(" << b.color() << ',' << BRUSH_STYLES[b.style()] << ')'; diff --git a/src/gui/painting/qcmyk_p.h b/src/gui/painting/qcmyk_p.h new file mode 100644 index 0000000000..d00a4b5a6e --- /dev/null +++ b/src/gui/painting/qcmyk_p.h @@ -0,0 +1,88 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef QCMYK_P_H +#define QCMYK_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <QtGui/private/qtguiglobal_p.h> +#include <QtGui/qcolor.h> + +QT_BEGIN_NAMESPACE + +class QCmyk32 +{ +private: + uint m_cmyk = 0; + +public: + QCmyk32() = default; + + constexpr QCmyk32(int cyan, int magenta, int yellow, int black) : +#if QT_BYTE_ORDER == Q_BIG_ENDIAN + m_cmyk(cyan << 24 | magenta << 16 | yellow << 8 | black) +#else + m_cmyk(cyan | magenta << 8 | yellow << 16 | black << 24) +#endif + { + } + +#if QT_BYTE_ORDER == Q_BIG_ENDIAN + constexpr int cyan() const noexcept { return (m_cmyk >> 24) & 0xff; } + constexpr int magenta() const noexcept { return (m_cmyk >> 16) & 0xff; } + constexpr int yellow() const noexcept { return (m_cmyk >> 8) & 0xff; } + constexpr int black() const noexcept { return (m_cmyk ) & 0xff; } +#else + constexpr int cyan() const noexcept { return (m_cmyk ) & 0xff; } + constexpr int magenta() const noexcept { return (m_cmyk >> 8) & 0xff; } + constexpr int yellow() const noexcept { return (m_cmyk >> 16) & 0xff; } + constexpr int black() const noexcept { return (m_cmyk >> 24) & 0xff; } +#endif + + QColor toColor() const noexcept + { + return QColor::fromCmyk(cyan(), magenta(), yellow(), black()); + } + + constexpr uint toUint() const noexcept + { + return m_cmyk; + } + + constexpr static QCmyk32 fromCmyk32(uint cmyk) noexcept + { + QCmyk32 result; + result.m_cmyk = cmyk; + return result; + } + + static QCmyk32 fromRgba(QRgb rgba) noexcept + { + const QColor c = QColor(rgba).toCmyk(); + return QCmyk32(c.cyan(), c.magenta(), c.yellow(), c.black()); + } + + static QCmyk32 fromColor(const QColor &color) noexcept + { + QColor c = color.toCmyk(); + return QCmyk32(c.cyan(), c.magenta(), c.yellow(), c.black()); + } +}; + +static_assert(sizeof(QCmyk32) == sizeof(int)); +static_assert(alignof(QCmyk32) == alignof(int)); +static_assert(std::is_standard_layout_v<QCmyk32>); + +QT_END_NAMESPACE + +#endif // QCMYK_P_H diff --git a/src/gui/painting/qcolor.cpp b/src/gui/painting/qcolor.cpp index 265e3496f3..2af2e8cb6b 100644 --- a/src/gui/painting/qcolor.cpp +++ b/src/gui/painting/qcolor.cpp @@ -784,12 +784,10 @@ QColor::QColor(Spec spec) noexcept } } -#if QT_DEPRECATED_SINCE(6, 6) +// ### Qt 7: remove those after deprecating them for the last Qt 6 LTS release /*! \fn QColor::QColor(const QString &name) - \deprecated [6.6] Use fromString() instead. - Constructs a named color in the same way as setNamedColor() using the given \a name. @@ -801,8 +799,6 @@ QColor::QColor(Spec spec) noexcept /*! \fn QColor::QColor(const char *name) - \deprecated [6.6] Use fromString() instead. - Constructs a named color in the same way as setNamedColor() using the given \a name. @@ -813,8 +809,6 @@ QColor::QColor(Spec spec) noexcept /*! \fn QColor::QColor(QLatin1StringView name) - \deprecated [6.6] Use fromString() instead. - Constructs a named color in the same way as setNamedColor() using the given \a name. @@ -822,7 +816,6 @@ QColor::QColor(Spec spec) noexcept \since 5.8 \sa setNamedColor(), name(), isValid() */ -#endif // QT_DEPRECATED_SINCE(6, 6) /*! \fn bool QColor::isValid() const @@ -1261,15 +1254,12 @@ void QColor::getRgbF(float *r, float *g, float *b, float *a) const if (!r || !g || !b) return; - if (cspec == Invalid) - return; - - if (cspec != Rgb && cspec != ExtendedRgb) { + if (cspec != Invalid && cspec != Rgb && cspec != ExtendedRgb) { toRgb().getRgbF(r, g, b, a); return; } - if (cspec == Rgb) { + if (cspec == Rgb || cspec == Invalid) { *r = ct.argb.red / float(USHRT_MAX); *g = ct.argb.green / float(USHRT_MAX); *b = ct.argb.blue / float(USHRT_MAX); @@ -1493,7 +1483,7 @@ void QColor::setAlpha(int alpha) QCOLOR_INT_RANGE_CHECK("QColor::setAlpha", alpha); if (cspec == ExtendedRgb) { constexpr float f = 1.0f / 255; - castF16(ct.argbExtended.alphaF16) = alpha * f; + castF16(ct.argbExtended.alphaF16) = qfloat16(alpha * f); return; } ct.argb.alpha = alpha * 0x101; @@ -1522,7 +1512,7 @@ void QColor::setAlphaF(float alpha) { QCOLOR_REAL_RANGE_CHECK("QColor::setAlphaF", alpha); if (cspec == ExtendedRgb) { - castF16(ct.argbExtended.alphaF16) = alpha; + castF16(ct.argbExtended.alphaF16) = qfloat16(alpha); return; } float tmp = alpha * USHRT_MAX; @@ -1640,7 +1630,7 @@ void QColor::setRedF(float red) if (cspec == Rgb && red >= 0.0f && red <= 1.0f) ct.argb.red = qRound(red * USHRT_MAX); else if (cspec == ExtendedRgb) - castF16(ct.argbExtended.redF16) = red; + castF16(ct.argbExtended.redF16) = qfloat16(red); else setRgbF(red, greenF(), blueF(), alphaF()); } @@ -1672,7 +1662,7 @@ void QColor::setGreenF(float green) if (cspec == Rgb && green >= 0.0f && green <= 1.0f) ct.argb.green = qRound(green * USHRT_MAX); else if (cspec == ExtendedRgb) - castF16(ct.argbExtended.greenF16) = green; + castF16(ct.argbExtended.greenF16) = qfloat16(green); else setRgbF(redF(), green, blueF(), alphaF()); } @@ -1702,7 +1692,7 @@ void QColor::setBlueF(float blue) if (cspec == Rgb && blue >= 0.0f && blue <= 1.0f) ct.argb.blue = qRound(blue * USHRT_MAX); else if (cspec == ExtendedRgb) - castF16(ct.argbExtended.blueF16) = blue; + castF16(ct.argbExtended.blueF16) = qfloat16(blue); else setRgbF(redF(), greenF(), blue, alphaF()); } diff --git a/src/gui/painting/qcolor.h b/src/gui/painting/qcolor.h index ba2621968b..2d6db1a14c 100644 --- a/src/gui/painting/qcolor.h +++ b/src/gui/painting/qcolor.h @@ -47,16 +47,10 @@ public: 0) {} QColor(QRgb rgb) noexcept; QColor(QRgba64 rgba64) noexcept; -#if QT_DEPRECATED_SINCE(6, 6) - QT_DEPRECATED_VERSION_X_6_6("Use QColor::fromString() instead.") inline QColor(const QString& name); - QT_DEPRECATED_VERSION_X_6_6("Use QColor::fromString() instead.") explicit inline QColor(QStringView name); - QT_DEPRECATED_VERSION_X_6_6("Use QColor::fromString() instead.") inline QColor(const char *aname); - QT_DEPRECATED_VERSION_X_6_6("Use QColor::fromString() instead.") inline QColor(QLatin1StringView name); -#endif QColor(Spec spec) noexcept; static QColor fromString(QAnyStringView name) noexcept; @@ -276,7 +270,6 @@ public: // can't give friendship to a namespace, so it needs to be public }; Q_DECLARE_TYPEINFO(QColor, Q_RELOCATABLE_TYPE); -#if QT_DEPRECATED_SINCE(6, 6) inline QColor::QColor(QLatin1StringView aname) : QColor(fromString(aname)) {} @@ -288,7 +281,6 @@ inline QColor::QColor(const QString& aname) inline QColor::QColor(const char *aname) : QColor(fromString(aname)) {} -#endif inline bool QColor::isValid() const noexcept { return cspec != Invalid; } diff --git a/src/gui/painting/qcolorclut_p.h b/src/gui/painting/qcolorclut_p.h new file mode 100644 index 0000000000..d95e9701b7 --- /dev/null +++ b/src/gui/painting/qcolorclut_p.h @@ -0,0 +1,127 @@ +// Copyright (C) 2024 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef QCOLORCLUT_H +#define QCOLORCLUT_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <QtCore/qlist.h> +#include <QtGui/private/qcolormatrix_p.h> + +QT_BEGIN_NAMESPACE + +// A 3/4-dimensional lookup table compatible with ICC lut8, lut16, mAB, and mBA formats. +class QColorCLUT +{ + inline static QColorVector interpolate(const QColorVector &a, const QColorVector &b, float t) + { + return a + (b - a) * t; // faster than std::lerp by assuming no super large or non-number floats + } + inline static void interpolateIn(QColorVector &a, const QColorVector &b, float t) + { + a += (b - a) * t; + } +public: + uint32_t gridPointsX = 0; + uint32_t gridPointsY = 0; + uint32_t gridPointsZ = 0; + uint32_t gridPointsW = 1; + QList<QColorVector> table; + + bool isEmpty() const { return table.isEmpty(); } + + QColorVector apply(const QColorVector &v) const + { + Q_ASSERT(table.size() == gridPointsX * gridPointsY * gridPointsZ * gridPointsW); + QColorVector frac; + const float x = std::clamp(v.x, 0.0f, 1.0f) * (gridPointsX - 1); + const float y = std::clamp(v.y, 0.0f, 1.0f) * (gridPointsY - 1); + const float z = std::clamp(v.z, 0.0f, 1.0f) * (gridPointsZ - 1); + const float w = std::clamp(v.w, 0.0f, 1.0f) * (gridPointsW - 1); + const uint32_t lox = static_cast<uint32_t>(std::floor(x)); + const uint32_t hix = std::min(lox + 1, gridPointsX - 1); + const uint32_t loy = static_cast<uint32_t>(std::floor(y)); + const uint32_t hiy = std::min(loy + 1, gridPointsY - 1); + const uint32_t loz = static_cast<uint32_t>(std::floor(z)); + const uint32_t hiz = std::min(loz + 1, gridPointsZ - 1); + const uint32_t low = static_cast<uint32_t>(std::floor(w)); + const uint32_t hiw = std::min(low + 1, gridPointsW - 1); + frac.x = x - static_cast<float>(lox); + frac.y = y - static_cast<float>(loy); + frac.z = z - static_cast<float>(loz); + frac.w = w - static_cast<float>(low); + if (gridPointsW > 1) { + auto index = [&](qsizetype x, qsizetype y, qsizetype z, qsizetype w) -> qsizetype { + return x * gridPointsW * gridPointsZ * gridPointsY + + y * gridPointsW * gridPointsZ + + z * gridPointsW + + w; + }; + QColorVector tmp[8]; + // interpolate over w + tmp[0] = interpolate(table[index(lox, loy, loz, low)], + table[index(lox, loy, loz, hiw)], frac.w); + tmp[1] = interpolate(table[index(lox, loy, hiz, low)], + table[index(lox, loy, hiz, hiw)], frac.w); + tmp[2] = interpolate(table[index(lox, hiy, loz, low)], + table[index(lox, hiy, loz, hiw)], frac.w); + tmp[3] = interpolate(table[index(lox, hiy, hiz, low)], + table[index(lox, hiy, hiz, hiw)], frac.w); + tmp[4] = interpolate(table[index(hix, loy, loz, low)], + table[index(hix, loy, loz, hiw)], frac.w); + tmp[5] = interpolate(table[index(hix, loy, hiz, low)], + table[index(hix, loy, hiz, hiw)], frac.w); + tmp[6] = interpolate(table[index(hix, hiy, loz, low)], + table[index(hix, hiy, loz, hiw)], frac.w); + tmp[7] = interpolate(table[index(hix, hiy, hiz, low)], + table[index(hix, hiy, hiz, hiw)], frac.w); + // interpolate over z + for (int i = 0; i < 4; ++i) + interpolateIn(tmp[i * 2], tmp[i * 2 + 1], frac.z); + // interpolate over y + for (int i = 0; i < 2; ++i) + interpolateIn(tmp[i * 4], tmp[i * 4 + 2], frac.y); + // interpolate over x + interpolateIn(tmp[0], tmp[4], frac.x); + return tmp[0]; + } + auto index = [&](qsizetype x, qsizetype y, qsizetype z) -> qsizetype { + return x * gridPointsZ * gridPointsY + + y * gridPointsZ + + z; + }; + QColorVector tmp[8] = { + table[index(lox, loy, loz)], + table[index(lox, loy, hiz)], + table[index(lox, hiy, loz)], + table[index(lox, hiy, hiz)], + table[index(hix, loy, loz)], + table[index(hix, loy, hiz)], + table[index(hix, hiy, loz)], + table[index(hix, hiy, hiz)] + }; + // interpolate over z + for (int i = 0; i < 4; ++i) + interpolateIn(tmp[i * 2], tmp[i * 2 + 1], frac.z); + // interpolate over y + for (int i = 0; i < 2; ++i) + interpolateIn(tmp[i * 4], tmp[i * 4 + 2], frac.y); + // interpolate over x + interpolateIn(tmp[0], tmp[4], frac.x); + return tmp[0]; + } +}; + +QT_END_NAMESPACE + +#endif // QCOLORCLUT_H diff --git a/src/gui/painting/qcolormatrix_p.h b/src/gui/painting/qcolormatrix_p.h index cda0d8229a..6a9b9f4f9a 100644 --- a/src/gui/painting/qcolormatrix_p.h +++ b/src/gui/painting/qcolormatrix_p.h @@ -1,4 +1,4 @@ -// Copyright (C) 2020 The Qt Company Ltd. +// Copyright (C) 2024 The Qt Company Ltd. // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only #ifndef QCOLORMATRIX_H @@ -18,6 +18,7 @@ #include <QtGui/qtguiglobal.h> #include <QtCore/qpoint.h> #include <QtCore/private/qglobal_p.h> +#include <QtCore/private/qsimd_p.h> #include <cmath> QT_BEGIN_NAMESPACE @@ -27,25 +28,24 @@ class QColorVector { public: QColorVector() = default; - constexpr QColorVector(float x, float y, float z) : x(x), y(y), z(z) { } - explicit constexpr QColorVector(const QPointF &chr) // from XY chromaticity - : x(chr.x() / chr.y()) - , y(1.0f) - , z((1.0 - chr.x() - chr.y()) / chr.y()) - { } - float x = 0.0f; // X, x or red - float y = 0.0f; // Y, y or green - float z = 0.0f; // Z, Y or blue - float _unused = 0.0f; + constexpr QColorVector(float x, float y, float z, float w = 0.0f) noexcept : x(x), y(y), z(z), w(w) { } + static constexpr QColorVector fromXYChromaticity(QPointF chr) + { return {float(chr.x() / chr.y()), 1.0f, float((1.0f - chr.x() - chr.y()) / chr.y())}; } + float x = 0.0f; // X, x, L, or red/cyan + float y = 0.0f; // Y, y, a, or green/magenta + float z = 0.0f; // Z, Y, b, or blue/yellow + float w = 0.0f; // unused, or black - friend inline bool operator==(const QColorVector &v1, const QColorVector &v2); - friend inline bool operator!=(const QColorVector &v1, const QColorVector &v2); - bool isNull() const + constexpr bool isNull() const noexcept { - return !x && !y && !z; + return !x && !y && !z && !w; + } + bool isValid() const noexcept + { + return std::isfinite(x) && std::isfinite(y) && std::isfinite(z); } - static bool isValidChromaticity(const QPointF &chr) + static constexpr bool isValidChromaticity(const QPointF &chr) { if (chr.x() < qreal(0.0) || chr.x() > qreal(1.0)) return false; @@ -56,26 +56,149 @@ public: return true; } + constexpr QColorVector operator*(float f) const { return QColorVector(x * f, y * f, z * f, w * f); } + constexpr QColorVector operator+(const QColorVector &v) const { return QColorVector(x + v.x, y + v.y, z + v.z, w + v.w); } + constexpr QColorVector operator-(const QColorVector &v) const { return QColorVector(x - v.x, y - v.y, z - v.z, w - v.w); } + void operator+=(const QColorVector &v) { x += v.x; y += v.y; z += v.z; w += v.w; } + + QPointF toChromaticity() const + { + if (isNull()) + return QPointF(); + float mag = 1.0f / (x + y + z); + return QPointF(x * mag, y * mag); + } + // Common whitepoints: static constexpr QPointF D50Chromaticity() { return QPointF(0.34567, 0.35850); } static constexpr QPointF D65Chromaticity() { return QPointF(0.31271, 0.32902); } - static constexpr QColorVector D50() { return QColorVector(D50Chromaticity()); } - static constexpr QColorVector D65() { return QColorVector(D65Chromaticity()); } + static constexpr QColorVector D50() { return fromXYChromaticity(D50Chromaticity()); } + static constexpr QColorVector D65() { return fromXYChromaticity(D65Chromaticity()); } + + QColorVector xyzToLab() const + { + constexpr QColorVector ref = D50(); + constexpr float eps = 0.008856f; + constexpr float kap = 903.3f; +#if defined(__SSE2__) + const __m128 iref = _mm_setr_ps(1.f / ref.x, 1.f / ref.y, 1.f / ref.z, 0.f); + __m128 v = _mm_loadu_ps(&x); + v = _mm_mul_ps(v, iref); + + const __m128 f3 = _mm_set1_ps(3.f); + __m128 est = _mm_add_ps(_mm_set1_ps(0.25f), _mm_mul_ps(v, _mm_set1_ps(0.75f))); // float est = 0.25f + (x * 0.75f); + __m128 estsq = _mm_mul_ps(est, est); + est = _mm_sub_ps(est, _mm_mul_ps(_mm_sub_ps(_mm_mul_ps(estsq, est), v), + _mm_rcp_ps(_mm_mul_ps(estsq, f3)))); // est -= ((est * est * est) - x) / (3.f * (est * est)); + estsq = _mm_mul_ps(est, est); + est = _mm_sub_ps(est, _mm_mul_ps(_mm_sub_ps(_mm_mul_ps(estsq, est), v), + _mm_rcp_ps(_mm_mul_ps(estsq, f3)))); // est -= ((est * est * est) - x) / (3.f * (est * est)); + estsq = _mm_mul_ps(est, est); + est = _mm_sub_ps(est, _mm_mul_ps(_mm_sub_ps(_mm_mul_ps(estsq, est), v), + _mm_rcp_ps(_mm_mul_ps(estsq, f3)))); // est -= ((est * est * est) - x) / (3.f * (est * est)); + estsq = _mm_mul_ps(est, est); + est = _mm_sub_ps(est, _mm_mul_ps(_mm_sub_ps(_mm_mul_ps(estsq, est), v), + _mm_rcp_ps(_mm_mul_ps(estsq, f3)))); // est -= ((est * est * est) - x) / (3.f * (est * est)); + + __m128 kapmul = _mm_mul_ps(_mm_add_ps(_mm_mul_ps(v, _mm_set1_ps(kap)), _mm_set1_ps(16.f)), + _mm_set1_ps(1.f / 116.f)); // f_ = (kap * f_ + 16.f) * (1.f / 116.f); + __m128 cmpgt = _mm_cmpgt_ps(v, _mm_set1_ps(eps)); // if (f_ > eps) +#if defined(__SSE4_1__) + v = _mm_blendv_ps(kapmul, est, cmpgt); // if (..) f_ =.. else f_ =.. +#else + v = _mm_or_ps(_mm_and_ps(cmpgt, est), _mm_andnot_ps(cmpgt, kapmul)); +#endif + alignas(16) float out[4]; + _mm_store_ps(out, v); + const float L = 116.f * out[1] - 16.f; + const float a = 500.f * (out[0] - out[1]); + const float b = 200.f * (out[1] - out[2]); +#else + float xr = x * (1.f / ref.x); + float yr = y * (1.f / ref.y); + float zr = z * (1.f / ref.z); + + float fx, fy, fz; + if (xr > eps) + fx = fastCbrt(xr); + else + fx = (kap * xr + 16.f) * (1.f / 116.f); + if (yr > eps) + fy = fastCbrt(yr); + else + fy = (kap * yr + 16.f) * (1.f / 116.f); + if (zr > eps) + fz = fastCbrt(zr); + else + fz = (kap * zr + 16.f) * (1.f / 116.f); + + const float L = 116.f * fy - 16.f; + const float a = 500.f * (fx - fy); + const float b = 200.f * (fy - fz); +#endif + // We output Lab values that has been scaled to 0.0->1.0 values, see also labToXyz. + return QColorVector(L * (1.f / 100.f), (a + 128.f) * (1.f / 255.f), (b + 128.f) * (1.f / 255.f)); + } + + QColorVector labToXyz() const + { + constexpr QColorVector ref = D50(); + constexpr float eps = 0.008856f; + constexpr float kap = 903.3f; + // This transform has been guessed from the ICC spec, but it is not stated + // anywhere to be the one to use to map to and from 0.0->1.0 values: + const float L = x * 100.f; + const float a = (y * 255.f) - 128.f; + const float b = (z * 255.f) - 128.f; + // From here is official Lab->XYZ conversion: + float fy = (L + 16.f) * (1.f / 116.f); + float fx = fy + (a * (1.f / 500.f)); + float fz = fy - (b * (1.f / 200.f)); + + float xr, yr, zr; + if (fx * fx * fx > eps) + xr = fx * fx * fx; + else + xr = (116.f * fx - 16) * (1.f / kap); + if (L > (kap * eps)) + yr = fy * fy * fy; + else + yr = L * (1.f / kap); + if (fz * fz * fz > eps) + zr = fz * fz * fz; + else + zr = (116.f * fz - 16) * (1.f / kap); + + xr = xr * ref.x; + yr = yr * ref.y; + zr = zr * ref.z; + return QColorVector(xr, yr, zr); + } + friend inline bool comparesEqual(const QColorVector &lhs, const QColorVector &rhs); + Q_DECLARE_EQUALITY_COMPARABLE(QColorVector); + +private: + static float fastCbrt(float x) + { + // This gives us cube root within the precision we need. + float est = 0.25f + (x * 0.75f); // guessing a cube-root of numbers between 0.01 and 1. + est -= ((est * est * est) - x) / (3.f * (est * est)); + est -= ((est * est * est) - x) / (3.f * (est * est)); + est -= ((est * est * est) - x) / (3.f * (est * est)); + est -= ((est * est * est) - x) / (3.f * (est * est)); + // Q_ASSERT(qAbs(est - std::cbrt(x)) < 0.0001f); + return est; + } }; -inline bool operator==(const QColorVector &v1, const QColorVector &v2) +inline bool comparesEqual(const QColorVector &v1, const QColorVector &v2) { return (std::abs(v1.x - v2.x) < (1.0f / 2048.0f)) && (std::abs(v1.y - v2.y) < (1.0f / 2048.0f)) - && (std::abs(v1.z - v2.z) < (1.0f / 2048.0f)); -} - -inline bool operator!=(const QColorVector &v1, const QColorVector &v2) -{ - return !(v1 == v2); + && (std::abs(v1.z - v2.z) < (1.0f / 2048.0f)) + && (std::abs(v1.w - v2.w) < (1.0f / 2048.0f)); } - // A matrix mapping 3 value colors. // Not using QTransform because only floats are needed and performance is critical. class QColorMatrix @@ -86,27 +209,29 @@ public: QColorVector g; QColorVector b; - friend inline bool operator==(const QColorMatrix &m1, const QColorMatrix &m2); - friend inline bool operator!=(const QColorMatrix &m1, const QColorMatrix &m2); - - bool isNull() const + constexpr bool isNull() const { return r.isNull() && g.isNull() && b.isNull(); } + constexpr float determinant() const + { + return r.x * (b.z * g.y - g.z * b.y) - + r.y * (b.z * g.x - g.z * b.x) + + r.z * (b.y * g.x - g.y * b.x); + } bool isValid() const { // A color matrix must be invertible - float det = r.x * (b.z * g.y - g.z * b.y) - - r.y * (b.z * g.x - g.z * b.x) + - r.z * (b.y * g.x - g.y * b.x); - return !qFuzzyIsNull(det); + return std::isnormal(determinant()); + } + bool isIdentity() const noexcept + { + return *this == identity(); } QColorMatrix inverted() const { - float det = r.x * (b.z * g.y - g.z * b.y) - - r.y * (b.z * g.x - g.z * b.x) + - r.z * (b.y * g.x - g.y * b.x); + float det = determinant(); det = 1.0f / det; QColorMatrix inv; inv.r.x = (g.y * b.z - b.y * g.z) * det; @@ -120,20 +245,20 @@ public: inv.b.z = (r.x * g.y - g.x * r.y) * det; return inv; } - QColorMatrix operator*(const QColorMatrix &o) const + friend inline constexpr QColorMatrix operator*(const QColorMatrix &a, const QColorMatrix &o) { QColorMatrix comb; - comb.r.x = r.x * o.r.x + g.x * o.r.y + b.x * o.r.z; - comb.g.x = r.x * o.g.x + g.x * o.g.y + b.x * o.g.z; - comb.b.x = r.x * o.b.x + g.x * o.b.y + b.x * o.b.z; + comb.r.x = a.r.x * o.r.x + a.g.x * o.r.y + a.b.x * o.r.z; + comb.g.x = a.r.x * o.g.x + a.g.x * o.g.y + a.b.x * o.g.z; + comb.b.x = a.r.x * o.b.x + a.g.x * o.b.y + a.b.x * o.b.z; - comb.r.y = r.y * o.r.x + g.y * o.r.y + b.y * o.r.z; - comb.g.y = r.y * o.g.x + g.y * o.g.y + b.y * o.g.z; - comb.b.y = r.y * o.b.x + g.y * o.b.y + b.y * o.b.z; + comb.r.y = a.r.y * o.r.x + a.g.y * o.r.y + a.b.y * o.r.z; + comb.g.y = a.r.y * o.g.x + a.g.y * o.g.y + a.b.y * o.g.z; + comb.b.y = a.r.y * o.b.x + a.g.y * o.b.y + a.b.y * o.b.z; - comb.r.z = r.z * o.r.x + g.z * o.r.y + b.z * o.r.z; - comb.g.z = r.z * o.g.x + g.z * o.g.y + b.z * o.g.z; - comb.b.z = r.z * o.b.x + g.z * o.b.y + b.z * o.b.z; + comb.r.z = a.r.z * o.r.x + a.g.z * o.r.y + a.b.z * o.r.z; + comb.g.z = a.r.z * o.g.x + a.g.z * o.g.y + a.b.z * o.g.z; + comb.b.z = a.r.z * o.b.x + a.g.z * o.b.y + a.b.z * o.b.z; return comb; } @@ -160,6 +285,32 @@ public: { 0.0f, v.y, 0.0f }, { 0.0f, 0.0f, v.z } }; } + static QColorMatrix chromaticAdaptation(const QColorVector &whitePoint) + { + constexpr QColorVector whitePointD50 = QColorVector::D50(); + if (whitePoint != whitePointD50) { + // A chromatic adaptation to map a white point to XYZ D50. + + // The Bradford method chromatic adaptation matrix: + const QColorMatrix abrad = { { 0.8951f, -0.7502f, 0.0389f }, + { 0.2664f, 1.7135f, -0.0685f }, + { -0.1614f, 0.0367f, 1.0296f } }; + const QColorMatrix abradinv = { { 0.9869929f, 0.4323053f, -0.0085287f }, + { -0.1470543f, 0.5183603f, 0.0400428f }, + { 0.1599627f, 0.0492912f, 0.9684867f } }; + + const QColorVector srcCone = abrad.map(whitePoint); + if (srcCone.x && srcCone.y && srcCone.z) { + const QColorVector dstCone = abrad.map(whitePointD50); + const QColorMatrix wToD50 = { { dstCone.x / srcCone.x, 0, 0 }, + { 0, dstCone.y / srcCone.y, 0 }, + { 0, 0, dstCone.z / srcCone.z } }; + return abradinv * (wToD50 * abrad); + } + } + return QColorMatrix::identity(); + } + // These are used to recognize matrices from ICC profiles: static QColorMatrix toXyzFromSRgb() { @@ -185,18 +336,15 @@ public: { 0.1351922452f, 0.7118769884f, 0.0000000000f }, { 0.0313525312f, 0.0000856627f, 0.8251883388f } }; } + friend inline bool comparesEqual(const QColorMatrix &lhs, const QColorMatrix &rhs); + Q_DECLARE_EQUALITY_COMPARABLE(QColorMatrix); }; -inline bool operator==(const QColorMatrix &m1, const QColorMatrix &m2) +inline bool comparesEqual(const QColorMatrix &m1, const QColorMatrix &m2) { return (m1.r == m2.r) && (m1.g == m2.g) && (m1.b == m2.b); } -inline bool operator!=(const QColorMatrix &m1, const QColorMatrix &m2) -{ - return !(m1 == m2); -} - QT_END_NAMESPACE #endif // QCOLORMATRIX_P_H diff --git a/src/gui/painting/qcolorspace.cpp b/src/gui/painting/qcolorspace.cpp index e8ced30727..7a1d34a408 100644 --- a/src/gui/painting/qcolorspace.cpp +++ b/src/gui/painting/qcolorspace.cpp @@ -5,6 +5,7 @@ #include "qcolorspace_p.h" #include "qcolortransform.h" +#include "qcolorclut_p.h" #include "qcolormatrix_p.h" #include "qcolortransferfunction_p.h" #include "qcolortransform_p.h" @@ -20,7 +21,7 @@ QT_BEGIN_NAMESPACE Q_CONSTINIT QBasicMutex QColorSpacePrivate::s_lutWriteLock; -static QAtomicPointer<QColorSpacePrivate> s_predefinedColorspacePrivates[QColorSpace::ProPhotoRgb] = {}; +Q_CONSTINIT static QAtomicPointer<QColorSpacePrivate> s_predefinedColorspacePrivates[QColorSpace::ProPhotoRgb] = {}; static void cleanupPredefinedColorspaces() { for (QAtomicPointer<QColorSpacePrivate> &ptr : s_predefinedColorspacePrivates) { @@ -80,49 +81,19 @@ bool QColorSpacePrimaries::areValid() const QColorMatrix QColorSpacePrimaries::toXyzMatrix() const { // This converts to XYZ in some undefined scale. - QColorMatrix toXyz = { QColorVector(redPoint), - QColorVector(greenPoint), - QColorVector(bluePoint) }; + QColorMatrix toXyz = { QColorVector::fromXYChromaticity(redPoint), + QColorVector::fromXYChromaticity(greenPoint), + QColorVector::fromXYChromaticity(bluePoint) }; // Since the white point should be (1.0, 1.0, 1.0) in the // input, we can figure out the scale by using the // inverse conversion on the white point. - QColorVector wXyz(whitePoint); + const auto wXyz = QColorVector::fromXYChromaticity(whitePoint); QColorVector whiteScale = toXyz.inverted().map(wXyz); // Now we have scaled conversion to XYZ relative to the given whitepoint toXyz = toXyz * QColorMatrix::fromScale(whiteScale); - // But we want a conversion to XYZ relative to D50 - QColorVector wXyzD50 = QColorVector::D50(); - - if (wXyz != wXyzD50) { - // Do chromatic adaptation to map our white point to XYZ D50. - - // The Bradford method chromatic adaptation matrix: - QColorMatrix abrad = { { 0.8951f, -0.7502f, 0.0389f }, - { 0.2664f, 1.7135f, -0.0685f }, - { -0.1614f, 0.0367f, 1.0296f } }; - QColorMatrix abradinv = { { 0.9869929f, 0.4323053f, -0.0085287f }, - { -0.1470543f, 0.5183603f, 0.0400428f }, - { 0.1599627f, 0.0492912f, 0.9684867f } }; - - QColorVector srcCone = abrad.map(wXyz); - QColorVector dstCone = abrad.map(wXyzD50); - - if (srcCone.x && srcCone.y && srcCone.z) { - QColorMatrix wToD50 = { { dstCone.x / srcCone.x, 0, 0 }, - { 0, dstCone.y / srcCone.y, 0 }, - { 0, 0, dstCone.z / srcCone.z } }; - - - QColorMatrix chromaticAdaptation = abradinv * (wToD50 * abrad); - toXyz = chromaticAdaptation * toXyz; - } else { - toXyz.r = {0, 0, 0}; // set to invalid value - } - } - return toXyz; } @@ -132,6 +103,7 @@ QColorSpacePrivate::QColorSpacePrivate() QColorSpacePrivate::QColorSpacePrivate(QColorSpace::NamedColorSpace namedColorSpace) : namedColorSpace(namedColorSpace) + , colorModel(QColorSpace::ColorModel::Rgb) { switch (namedColorSpace) { case QColorSpace::SRgb: @@ -169,6 +141,7 @@ QColorSpacePrivate::QColorSpacePrivate(QColorSpace::NamedColorSpace namedColorSp QColorSpacePrivate::QColorSpacePrivate(QColorSpace::Primaries primaries, QColorSpace::TransferFunction transferFunction, float gamma) : primaries(primaries) , transferFunction(transferFunction) + , colorModel(QColorSpace::ColorModel::Rgb) , gamma(gamma) { identifyColorSpace(); @@ -180,18 +153,50 @@ QColorSpacePrivate::QColorSpacePrivate(const QColorSpacePrimaries &primaries, float gamma) : primaries(QColorSpace::Primaries::Custom) , transferFunction(transferFunction) + , colorModel(QColorSpace::ColorModel::Rgb) , gamma(gamma) + , whitePoint(QColorVector::fromXYChromaticity(primaries.whitePoint)) { Q_ASSERT(primaries.areValid()); toXyz = primaries.toXyzMatrix(); - whitePoint = QColorVector(primaries.whitePoint); + chad = QColorMatrix::chromaticAdaptation(whitePoint); + toXyz = chad * toXyz; + identifyColorSpace(); setTransferFunction(); } +QColorSpacePrivate::QColorSpacePrivate(const QPointF &whitePoint, + QColorSpace::TransferFunction transferFunction, + float gamma) + : primaries(QColorSpace::Primaries::Custom) + , transferFunction(transferFunction) + , colorModel(QColorSpace::ColorModel::Gray) + , gamma(gamma) + , whitePoint(QColorVector::fromXYChromaticity(whitePoint)) +{ + chad = QColorMatrix::chromaticAdaptation(this->whitePoint); + toXyz = chad; + setTransferFunction(); +} + +QColorSpacePrivate::QColorSpacePrivate(const QPointF &whitePoint, const QList<uint16_t> &transferFunctionTable) + : primaries(QColorSpace::Primaries::Custom) + , transferFunction(QColorSpace::TransferFunction::Custom) + , colorModel(QColorSpace::ColorModel::Gray) + , gamma(0) + , whitePoint(QColorVector::fromXYChromaticity(whitePoint)) +{ + chad = QColorMatrix::chromaticAdaptation(this->whitePoint); + toXyz = chad; + setTransferFunctionTable(transferFunctionTable); + setTransferFunction(); +} + QColorSpacePrivate::QColorSpacePrivate(QColorSpace::Primaries primaries, const QList<uint16_t> &transferFunctionTable) : primaries(primaries) , transferFunction(QColorSpace::TransferFunction::Custom) + , colorModel(QColorSpace::ColorModel::Rgb) , gamma(0) { setTransferFunctionTable(transferFunctionTable); @@ -202,11 +207,14 @@ QColorSpacePrivate::QColorSpacePrivate(QColorSpace::Primaries primaries, const Q QColorSpacePrivate::QColorSpacePrivate(const QColorSpacePrimaries &primaries, const QList<uint16_t> &transferFunctionTable) : primaries(QColorSpace::Primaries::Custom) , transferFunction(QColorSpace::TransferFunction::Custom) + , colorModel(QColorSpace::ColorModel::Rgb) , gamma(0) + , whitePoint(QColorVector::fromXYChromaticity(primaries.whitePoint)) { Q_ASSERT(primaries.areValid()); toXyz = primaries.toXyzMatrix(); - whitePoint = QColorVector(primaries.whitePoint); + chad = QColorMatrix::chromaticAdaptation(whitePoint); + toXyz = chad * toXyz; setTransferFunctionTable(transferFunctionTable); identifyColorSpace(); initialize(); @@ -218,16 +226,18 @@ QColorSpacePrivate::QColorSpacePrivate(const QColorSpacePrimaries &primaries, const QList<uint16_t> &blueTransferFunctionTable) : primaries(QColorSpace::Primaries::Custom) , transferFunction(QColorSpace::TransferFunction::Custom) + , colorModel(QColorSpace::ColorModel::Rgb) , gamma(0) { Q_ASSERT(primaries.areValid()); toXyz = primaries.toXyzMatrix(); - whitePoint = QColorVector(primaries.whitePoint); + whitePoint = QColorVector::fromXYChromaticity(primaries.whitePoint); + chad = QColorMatrix::chromaticAdaptation(whitePoint); + toXyz = chad * toXyz; setTransferFunctionTables(redTransferFunctionTable, greenTransferFunctionTable, blueTransferFunctionTable); identifyColorSpace(); - setToXyzMatrix(); } void QColorSpacePrivate::identifyColorSpace() @@ -304,7 +314,9 @@ void QColorSpacePrivate::setToXyzMatrix() } QColorSpacePrimaries colorSpacePrimaries(primaries); toXyz = colorSpacePrimaries.toXyzMatrix(); - whitePoint = QColorVector(colorSpacePrimaries.whitePoint); + whitePoint = QColorVector::fromXYChromaticity(colorSpacePrimaries.whitePoint); + chad = QColorMatrix::chromaticAdaptation(whitePoint); + toXyz = chad * toXyz; } void QColorSpacePrivate::setTransferFunctionTable(const QList<uint16_t> &transferFunctionTable) @@ -319,7 +331,7 @@ void QColorSpacePrivate::setTransferFunctionTable(const QList<uint16_t> &transfe QColorTransferFunction curve; if (table.asColorTransferFunction(&curve)) { // Table recognized as a specific curve - if (curve.isLinear()) { + if (curve.isIdentity()) { transferFunction = QColorSpace::TransferFunction::Linear; gamma = 1.0f; } else if (curve.isSRgb()) { @@ -418,7 +430,14 @@ QColorTransform QColorSpacePrivate::transformationToColorSpace(const QColorSpace combined.d = ptr; ptr->colorSpaceIn = this; ptr->colorSpaceOut = out; - ptr->colorMatrix = out->toXyz.inverted() * toXyz; + if (isThreeComponentMatrix()) + ptr->colorMatrix = toXyz; + else + ptr->colorMatrix = QColorMatrix::identity(); + if (out->isThreeComponentMatrix()) + ptr->colorMatrix = out->toXyz.inverted() * ptr->colorMatrix; + if (ptr->isIdentity()) + return QColorTransform(); return combined; } @@ -429,10 +448,32 @@ QColorTransform QColorSpacePrivate::transformationToXYZ() const transform.d = ptr; ptr->colorSpaceIn = this; ptr->colorSpaceOut = this; - ptr->colorMatrix = toXyz; + // Convert to XYZ relative to our white point, not the regular D50 white point. + if (isThreeComponentMatrix()) + ptr->colorMatrix = QColorMatrix::chromaticAdaptation(whitePoint).inverted() * toXyz; + else + ptr->colorMatrix = QColorMatrix::identity(); return transform; } +bool QColorSpacePrivate::isThreeComponentMatrix() const +{ + return transformModel == QColorSpace::TransformModel::ThreeComponentMatrix; +} + +void QColorSpacePrivate::clearElementListProcessingForEdit() +{ + Q_ASSERT(transformModel == QColorSpace::TransformModel::ElementListProcessing); + Q_ASSERT(primaries == QColorSpace::Primaries::Custom); + Q_ASSERT(transferFunction == QColorSpace::TransferFunction::Custom); + + transformModel = QColorSpace::TransformModel::ThreeComponentMatrix; + colorModel = QColorSpace::ColorModel::Rgb; + isPcsLab = false; + mAB.clear(); + mBA.clear(); +} + /*! \class QColorSpace \brief The QColorSpace class provides a color space abstraction. @@ -455,9 +496,10 @@ QColorTransform QColorSpacePrivate::transformationToXYZ() const A color space can generally speaking be conceived as a combination of set of primary colors and a transfer function. The primaries defines the axes of the color space, and the transfer function how values are mapped on the axes. - The primaries are defined by three primary colors that represent exactly how red, green, - and blue look in this particular color space, and a white color that represents where - and how bright pure white is. The range of colors expressible by the primary colors is + The primaries are for ColorModel::Rgb color spaces defined by three primary colors that + represent exactly how red, green, and blue look in this particular color space, and a white + color that represents where and how bright pure white is. For grayscale color spaces, only + a single white primary is needed. The range of colors expressible by the primary colors is called the gamut, and a color space that can represent a wider range of colors is also known as a wide-gamut color space. @@ -511,6 +553,35 @@ QColorTransform QColorSpacePrivate::transformationToXYZ() const */ /*! + \enum QColorSpace::TransformModel + \since 6.8 + + Defines the processing model used for color space transforms. + + \value ThreeComponentMatrix The transform consist of a matrix calculated from primaries and set of transfer functions + for each color channel. This is very fast and used by all predefined color spaces. Any color space on this form is + reversible and always both valid sources and targets. + \value ElementListProcessing The transforms are one or two lists of processing elements that can do many things, + each list only process either to the connection color space or from it. This is very flexible, but rather + slow, and can only be set by reading ICC profiles (See \l fromIccProfile()). Since the two lists are + separate a color space on this form can be a valid source, but not necessarily also a valid target. When changing + either primaries or transfer function on a color space on this type it will reset to an empty ThreeComponentMatrix form. +*/ + +/*! + \enum QColorSpace::ColorModel + \since 6.8 + + Defines the color model used by the color space data. + + \value Undefined No color model + \value Rgb An RGB color model with red, green, and blue colors. Can apply to RGB and grayscale data. + \value Gray A gray scale color model. Can only apply to grayscale data. + \value Cmyk Can only represent color data defined with cyan, magenta, yellow, and black colors. + In effect only QImage::Format_CMYK32. Note Cmyk color spaces will be TransformModel::ElementListProcessing. +*/ + +/*! \fn QColorSpace::QColorSpace() Creates a new colorspace object that represents an undefined and invalid colorspace. @@ -573,6 +644,28 @@ QColorSpace::QColorSpace(QColorSpace::Primaries gamut, const QList<uint16_t> &tr } /*! + Creates a custom grayscale color space with the white point \a whitePoint, using the transfer function \a transferFunction and + optionally \a gamma. + + \since 6.8 +*/ +QColorSpace::QColorSpace(const QPointF &whitePoint, TransferFunction transferFunction, float gamma) + : d_ptr(new QColorSpacePrivate(whitePoint, transferFunction, gamma)) +{ +} + +/*! + Creates a custom grayscale color space with white point \a whitePoint, and using the custom transfer function described by + \a transferFunctionTable. + + \since 6.8 +*/ +QColorSpace::QColorSpace(const QPointF &whitePoint, const QList<uint16_t> &transferFunctionTable) + : d_ptr(new QColorSpacePrivate(whitePoint, transferFunctionTable)) +{ +} + +/*! Creates a custom colorspace with a primaries based on the chromaticities of the primary colors \a whitePoint, \a redPoint, \a greenPoint and \a bluePoint, and using the transfer function \a transferFunction and optionally \a gamma. */ @@ -687,7 +780,10 @@ void QColorSpace::setTransferFunction(QColorSpace::TransferFunction transferFunc if (d_ptr->transferFunction == transferFunction && d_ptr->gamma == gamma) return; detach(); - d_ptr->description.clear(); + if (d_ptr->transformModel == TransformModel::ElementListProcessing) + d_ptr->clearElementListProcessingForEdit(); + d_ptr->iccProfile = {}; + d_ptr->description = QString(); d_ptr->transferFunction = transferFunction; d_ptr->gamma = gamma; d_ptr->identifyColorSpace(); @@ -708,7 +804,10 @@ void QColorSpace::setTransferFunction(const QList<uint16_t> &transferFunctionTab return; } detach(); - d_ptr->description.clear(); + if (d_ptr->transformModel == TransformModel::ElementListProcessing) + d_ptr->clearElementListProcessingForEdit(); + d_ptr->iccProfile = {}; + d_ptr->description = QString(); d_ptr->setTransferFunctionTable(transferFunctionTable); d_ptr->gamma = 0; d_ptr->identifyColorSpace(); @@ -735,7 +834,10 @@ void QColorSpace::setTransferFunctions(const QList<uint16_t> &redTransferFunctio return; } detach(); - d_ptr->description.clear(); + if (d_ptr->transformModel == TransformModel::ElementListProcessing) + d_ptr->clearElementListProcessingForEdit(); + d_ptr->iccProfile = {}; + d_ptr->description = QString(); d_ptr->setTransferFunctionTables(redTransferFunctionTable, greenTransferFunctionTable, blueTransferFunctionTable); @@ -751,7 +853,7 @@ void QColorSpace::setTransferFunctions(const QList<uint16_t> &redTransferFunctio */ QColorSpace QColorSpace::withTransferFunction(QColorSpace::TransferFunction transferFunction, float gamma) const { - if (!isValid() || transferFunction == QColorSpace::TransferFunction::Custom) + if (!isValid() || transferFunction == TransferFunction::Custom) return *this; if (d_ptr->transferFunction == transferFunction && d_ptr->gamma == gamma) return *this; @@ -811,8 +913,12 @@ void QColorSpace::setPrimaries(QColorSpace::Primaries primariesId) if (d_ptr->primaries == primariesId) return; detach(); - d_ptr->description.clear(); + if (d_ptr->transformModel == TransformModel::ElementListProcessing) + d_ptr->clearElementListProcessingForEdit(); + d_ptr->iccProfile = {}; + d_ptr->description = QString(); d_ptr->primaries = primariesId; + d_ptr->colorModel = QColorSpace::ColorModel::Rgb; d_ptr->identifyColorSpace(); d_ptr->setToXyzMatrix(); } @@ -834,17 +940,100 @@ void QColorSpace::setPrimaries(const QPointF &whitePoint, const QPointF &redPoin return; } QColorMatrix toXyz = primaries.toXyzMatrix(); - if (QColorVector(primaries.whitePoint) == d_ptr->whitePoint && toXyz == d_ptr->toXyz) + QColorMatrix chad = QColorMatrix::chromaticAdaptation(QColorVector::fromXYChromaticity(whitePoint)); + toXyz = chad * toXyz; + if (QColorVector::fromXYChromaticity(primaries.whitePoint) == d_ptr->whitePoint + && toXyz == d_ptr->toXyz && chad == d_ptr->chad) return; detach(); - d_ptr->description.clear(); + if (d_ptr->transformModel == TransformModel::ElementListProcessing) + d_ptr->clearElementListProcessingForEdit(); + d_ptr->iccProfile = {}; + d_ptr->description = QString(); d_ptr->primaries = QColorSpace::Primaries::Custom; + d_ptr->colorModel = QColorSpace::ColorModel::Rgb; d_ptr->toXyz = toXyz; - d_ptr->whitePoint = QColorVector(primaries.whitePoint); + d_ptr->chad = chad; + d_ptr->whitePoint = QColorVector::fromXYChromaticity(primaries.whitePoint); + d_ptr->identifyColorSpace(); +} + +/*! + Returns the white point used for this color space. Returns a null QPointF if not defined. + + \since 6.8 +*/ +QPointF QColorSpace::whitePoint() const +{ + if (Q_UNLIKELY(!d_ptr)) + return QPointF(); + return d_ptr->whitePoint.toChromaticity(); +} + +/*! + Sets the white point to used for this color space to \a whitePoint. + + \since 6.8 +*/ +void QColorSpace::setWhitePoint(const QPointF &whitePoint) +{ + if (Q_UNLIKELY(!d_ptr)) { + d_ptr = new QColorSpacePrivate(whitePoint, TransferFunction::Custom, 0.0f); + return; + } + if (QColorVector::fromXYChromaticity(whitePoint) == d_ptr->whitePoint) + return; + detach(); + if (d_ptr->transformModel == TransformModel::ElementListProcessing) + d_ptr->clearElementListProcessingForEdit(); + d_ptr->iccProfile = {}; + d_ptr->description = QString(); + d_ptr->primaries = QColorSpace::Primaries::Custom; + // An RGB color model stays RGB, a gray stays gray, but an undefined one can now be considered gray + if (d_ptr->colorModel == QColorSpace::ColorModel::Undefined) + d_ptr->colorModel = QColorSpace::ColorModel::Gray; + QColorVector wXyz(QColorVector::fromXYChromaticity(whitePoint)); + if (d_ptr->transformModel == QColorSpace::TransformModel::ThreeComponentMatrix) { + if (d_ptr->colorModel == QColorSpace::ColorModel::Rgb) { + // Rescale toXyz to new whitepoint + QColorMatrix rawToXyz = d_ptr->chad.inverted() * d_ptr->toXyz; + QColorVector whiteScale = rawToXyz.inverted().map(wXyz); + rawToXyz = rawToXyz * QColorMatrix::fromScale(whiteScale); + d_ptr->chad = QColorMatrix::chromaticAdaptation(wXyz); + d_ptr->toXyz = d_ptr->chad * rawToXyz; + } else if (d_ptr->colorModel == QColorSpace::ColorModel::Gray) { + d_ptr->chad = d_ptr->toXyz = QColorMatrix::chromaticAdaptation(wXyz); + } + } + d_ptr->whitePoint = wXyz; d_ptr->identifyColorSpace(); } /*! + Returns the transfrom processing model used for this color space. + + \since 6.8 +*/ +QColorSpace::TransformModel QColorSpace::transformModel() const noexcept +{ + if (Q_UNLIKELY(!d_ptr)) + return QColorSpace::TransformModel::ThreeComponentMatrix; + return d_ptr->transformModel; +} + +/*! + Returns the color model this color space can represent + + \since 6.8 +*/ +QColorSpace::ColorModel QColorSpace::colorModel() const noexcept +{ + if (Q_UNLIKELY(!d_ptr)) + return QColorSpace::ColorModel::Undefined; + return d_ptr->colorModel; +} + +/*! \internal */ void QColorSpace::detach() @@ -882,7 +1071,7 @@ QByteArray QColorSpace::iccProfile() const Creates a QColorSpace from ICC profile \a iccProfile. \note Not all ICC profiles are supported. QColorSpace only supports - RGB-XYZ ICC profiles that are three-component matrix-based. + RGB or Gray ICC profiles. If the ICC profile is not supported an invalid QColorSpace is returned where you can still read the original ICC profile using iccProfile(). @@ -900,13 +1089,51 @@ QColorSpace QColorSpace::fromIccProfile(const QByteArray &iccProfile) } /*! - Returns \c true if the color space is valid. + Returns \c true if the color space is valid. For a color space with \c TransformModel::ThreeComponentMatrix + that means both primaries and transfer functions set, and implies isValidTarget(). + For a color space with \c TransformModel::ElementListProcessing it means it has a valid source transform, to + check if it also a valid target color space use isValidTarget(). + + \sa isValidTarget() */ bool QColorSpace::isValid() const noexcept { - return d_ptr - && d_ptr->toXyz.isValid() - && d_ptr->trc[0].isValid() && d_ptr->trc[1].isValid() && d_ptr->trc[2].isValid(); + if (!d_ptr) + return false; + return d_ptr->isValid(); +} + +/*! + \since 6.8 + + Returns \c true if the color space is a valid target color space. +*/ +bool QColorSpace::isValidTarget() const noexcept +{ + if (!d_ptr) + return false; + if (!d_ptr->isThreeComponentMatrix()) + return !d_ptr->mBA.isEmpty(); + return d_ptr->isValid(); +} + +/*! + \internal +*/ +bool QColorSpacePrivate::isValid() const noexcept +{ + if (!isThreeComponentMatrix()) + return !mAB.isEmpty(); + if (!toXyz.isValid()) + return false; + if (colorModel == QColorSpace::ColorModel::Gray) { + if (!trc[0].isValid()) + return false; + } else { + if (!trc[0].isValid() || !trc[1].isValid() || !trc[2].isValid()) + return false; + } + return true; } /*! @@ -923,6 +1150,53 @@ bool QColorSpace::isValid() const noexcept otherwise returns \c false */ +static bool compareElement(const QColorSpacePrivate::TransferElement &element, + const QColorSpacePrivate::TransferElement &other) +{ + return element.trc[0] == other.trc[0] + && element.trc[1] == other.trc[1] + && element.trc[2] == other.trc[2] + && element.trc[3] == other.trc[3]; +} + +static bool compareElement(const QColorMatrix &element, + const QColorMatrix &other) +{ + return element == other; +} + +static bool compareElement(const QColorVector &element, + const QColorVector &other) +{ + return element == other; +} + +static bool compareElement(const QColorCLUT &element, + const QColorCLUT &other) +{ + if (element.gridPointsX != other.gridPointsX) + return false; + if (element.gridPointsY != other.gridPointsY) + return false; + if (element.gridPointsZ != other.gridPointsZ) + return false; + if (element.gridPointsW != other.gridPointsW) + return false; + if (element.table.size() != other.table.size()) + return false; + for (qsizetype i = 0; i < element.table.size(); ++i) { + if (element.table[i] != other.table[i]) + return false; + } + return true; +} + +template<typename T> +static bool compareElements(const T &element, const QColorSpacePrivate::Element &other) +{ + return compareElement(element, std::get<T>(other)); +} + /*! \internal */ @@ -930,43 +1204,89 @@ bool QColorSpace::equals(const QColorSpace &other) const { if (d_ptr == other.d_ptr) return true; - if (!d_ptr || !other.d_ptr) + if (!d_ptr) return false; + return d_ptr->equals(other.d_ptr.constData()); +} - if (d_ptr->namedColorSpace && other.d_ptr->namedColorSpace) - return d_ptr->namedColorSpace == other.d_ptr->namedColorSpace; +/*! + \internal +*/ +bool QColorSpacePrivate::equals(const QColorSpacePrivate *other) const +{ + if (!other) + return false; + + if (namedColorSpace && other->namedColorSpace) + return namedColorSpace == other->namedColorSpace; const bool valid1 = isValid(); - const bool valid2 = other.isValid(); + const bool valid2 = other->isValid(); if (valid1 != valid2) return false; if (!valid1 && !valid2) { - if (!d_ptr->iccProfile.isEmpty() || !other.d_ptr->iccProfile.isEmpty()) - return d_ptr->iccProfile == other.d_ptr->iccProfile; + if (!iccProfile.isEmpty() || !other->iccProfile.isEmpty()) + return iccProfile == other->iccProfile; + return false; } // At this point one or both color spaces are unknown, and must be compared in detail instead - if (primaries() != QColorSpace::Primaries::Custom && other.primaries() != QColorSpace::Primaries::Custom) { - if (primaries() != other.primaries()) + if (transformModel != other->transformModel) + return false; + + if (!isThreeComponentMatrix()) { + if (isPcsLab != other->isPcsLab) + return false; + if (colorModel != other->colorModel) + return false; + if (mAB.count() != other->mAB.count()) + return false; + if (mBA.count() != other->mBA.count()) + return false; + + // Compare element types + for (qsizetype i = 0; i < mAB.count(); ++i) { + if (mAB[i].index() != other->mAB[i].index()) + return false; + } + for (qsizetype i = 0; i < mBA.count(); ++i) { + if (mBA[i].index() != other->mBA[i].index()) + return false; + } + + // Compare element contents + for (qsizetype i = 0; i < mAB.count(); ++i) { + if (!std::visit([&](auto &&elm) { return compareElements(elm, other->mAB[i]); }, mAB[i])) + return false; + } + for (qsizetype i = 0; i < mBA.count(); ++i) { + if (!std::visit([&](auto &&elm) { return compareElements(elm, other->mBA[i]); }, mBA[i])) + return false; + } + + return true; + } + + if (primaries != QColorSpace::Primaries::Custom && other->primaries != QColorSpace::Primaries::Custom) { + if (primaries != other->primaries) return false; } else { - if (d_ptr->toXyz != other.d_ptr->toXyz) + if (toXyz != other->toXyz) return false; } - if (transferFunction() != QColorSpace::TransferFunction::Custom && - other.transferFunction() != QColorSpace::TransferFunction::Custom) { - if (transferFunction() != other.transferFunction()) + if (transferFunction != QColorSpace::TransferFunction::Custom && other->transferFunction != QColorSpace::TransferFunction::Custom) { + if (transferFunction != other->transferFunction) return false; - if (transferFunction() == QColorSpace::TransferFunction::Gamma) - return (qAbs(gamma() - other.gamma()) <= (1.0f / 512.0f)); + if (transferFunction == QColorSpace::TransferFunction::Gamma) + return (qAbs(gamma - other->gamma) <= (1.0f / 512.0f)); return true; } - if (d_ptr->trc[0] != other.d_ptr->trc[0] || - d_ptr->trc[1] != other.d_ptr->trc[1] || - d_ptr->trc[2] != other.d_ptr->trc[2]) + if (trc[0] != other->trc[0] || + trc[1] != other->trc[1] || + trc[2] != other->trc[2]) return false; return true; @@ -978,9 +1298,16 @@ bool QColorSpace::equals(const QColorSpace &other) const */ QColorTransform QColorSpace::transformationToColorSpace(const QColorSpace &colorspace) const { - if (!isValid() || !colorspace.isValid()) + if (!isValid()) return QColorTransform(); + if (*this == colorspace) + return QColorTransform(); + if (!colorspace.isValidTarget()) { + qWarning() << "QColorSpace::transformationToColorSpace: colorspace not a valid target"; + return QColorTransform(); + } + return d_ptr->transformationToColorSpace(colorspace.d_ptr.get()); } @@ -1019,6 +1346,7 @@ QString QColorSpace::description() const noexcept void QColorSpace::setDescription(const QString &description) { detach(); + d_ptr->iccProfile = {}; d_ptr->userDescription = description; } @@ -1061,6 +1389,28 @@ QDataStream &operator>>(QDataStream &s, QColorSpace &colorSpace) #endif // QT_NO_DATASTREAM #ifndef QT_NO_DEBUG_STREAM +QDebug operator<<(QDebug dbg, const QColorSpacePrivate::TransferElement &) +{ + return dbg << ":Transfer"; +} +QDebug operator<<(QDebug dbg, const QColorMatrix &) +{ + return dbg << ":Matrix"; +} +QDebug operator<<(QDebug dbg, const QColorVector &) +{ + return dbg << ":Offset"; +} +QDebug operator<<(QDebug dbg, const QColorCLUT &) +{ + return dbg << ":CLUT"; +} +QDebug operator<<(QDebug dbg, const QList<QColorSpacePrivate::Element> &elements) +{ + for (auto &&element : elements) + std::visit([&](auto &&elm) { dbg << elm; }, element); + return dbg; +} QDebug operator<<(QDebug dbg, const QColorSpace &colorSpace) { QDebugStateSaver saver(dbg); @@ -1069,8 +1419,22 @@ QDebug operator<<(QDebug dbg, const QColorSpace &colorSpace) if (colorSpace.d_ptr) { if (colorSpace.d_ptr->namedColorSpace) dbg << colorSpace.d_ptr->namedColorSpace << ", "; - dbg << colorSpace.primaries() << ", " << colorSpace.transferFunction(); - dbg << ", gamma=" << colorSpace.gamma(); + if (!colorSpace.isValid()) { + dbg << "Invalid"; + if (!colorSpace.d_ptr->iccProfile.isEmpty()) + dbg << " with profile data"; + } else if (colorSpace.d_ptr->isThreeComponentMatrix()) { + dbg << colorSpace.primaries() << ", " << colorSpace.transferFunction(); + dbg << ", gamma=" << colorSpace.gamma(); + } else { + if (colorSpace.d_ptr->isPcsLab) + dbg << "PCSLab, "; + else + dbg << "PCSXYZ, "; + dbg << "A2B" << colorSpace.d_ptr->mAB; + if (!colorSpace.d_ptr->mBA.isEmpty()) + dbg << ", B2A" << colorSpace.d_ptr->mBA; + } } dbg << ')'; return dbg; diff --git a/src/gui/painting/qcolorspace.h b/src/gui/painting/qcolorspace.h index 4fb5c4273f..488cbd6a53 100644 --- a/src/gui/painting/qcolorspace.h +++ b/src/gui/painting/qcolorspace.h @@ -45,9 +45,23 @@ public: ProPhotoRgb }; Q_ENUM(TransferFunction) + enum class TransformModel : uint8_t { + ThreeComponentMatrix = 0, + ElementListProcessing, + }; + Q_ENUM(TransformModel) + enum class ColorModel : uint8_t { + Undefined = 0, + Rgb = 1, + Gray = 2, + Cmyk = 3, + }; + Q_ENUM(ColorModel) QColorSpace() noexcept = default; QColorSpace(NamedColorSpace namedColorSpace); + QColorSpace(const QPointF &whitePoint, TransferFunction transferFunction, float gamma = 0.0f); + QColorSpace(const QPointF &whitePoint, const QList<uint16_t> &transferFunctionTable); QColorSpace(Primaries primaries, TransferFunction transferFunction, float gamma = 0.0f); QColorSpace(Primaries primaries, float gamma); QColorSpace(Primaries primaries, const QList<uint16_t> &transferFunctionTable); @@ -99,9 +113,14 @@ public: void setPrimaries(Primaries primariesId); void setPrimaries(const QPointF &whitePoint, const QPointF &redPoint, const QPointF &greenPoint, const QPointF &bluePoint); + void setWhitePoint(const QPointF &whitePoint); + QPointF whitePoint() const; + TransformModel transformModel() const noexcept; + ColorModel colorModel() const noexcept; void detach(); bool isValid() const noexcept; + bool isValidTarget() const noexcept; friend inline bool operator==(const QColorSpace &colorSpace1, const QColorSpace &colorSpace2) { return colorSpace1.equals(colorSpace2); } diff --git a/src/gui/painting/qcolorspace_p.h b/src/gui/painting/qcolorspace_p.h index dd668fcd41..4ec801b16b 100644 --- a/src/gui/painting/qcolorspace_p.h +++ b/src/gui/painting/qcolorspace_p.h @@ -1,4 +1,4 @@ -// Copyright (C) 2018 The Qt Company Ltd. +// Copyright (C) 2024 The Qt Company Ltd. // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only #ifndef QCOLORSPACE_P_H @@ -16,6 +16,7 @@ // #include "qcolorspace.h" +#include "qcolorclut_p.h" #include "qcolormatrix_p.h" #include "qcolortrc_p.h" #include "qcolortrclut_p.h" @@ -65,6 +66,8 @@ public: const QList<uint16_t> &redTransferFunctionTable, const QList<uint16_t> &greenTransferFunctionTable, const QList<uint16_t> &blueRransferFunctionTable); + QColorSpacePrivate(const QPointF &whitePoint, QColorSpace::TransferFunction transferFunction, float gamma); + QColorSpacePrivate(const QPointF &whitePoint, const QList<uint16_t> &transferFunctionTable); QColorSpacePrivate(const QColorSpacePrivate &other) = default; static const QColorSpacePrivate *get(const QColorSpace &colorSpace) @@ -77,6 +80,9 @@ public: return colorSpace.d_ptr.get(); } + bool equals(const QColorSpacePrivate *other) const; + bool isValid() const noexcept; + void initialize(); void setToXyzMatrix(); void setTransferFunction(); @@ -88,22 +94,40 @@ public: QColorTransform transformationToColorSpace(const QColorSpacePrivate *out) const; QColorTransform transformationToXYZ() const; + bool isThreeComponentMatrix() const; + void clearElementListProcessingForEdit(); + static constexpr QColorSpace::NamedColorSpace Unknown = QColorSpace::NamedColorSpace(0); QColorSpace::NamedColorSpace namedColorSpace = Unknown; QColorSpace::Primaries primaries = QColorSpace::Primaries::Custom; QColorSpace::TransferFunction transferFunction = QColorSpace::TransferFunction::Custom; + QColorSpace::TransformModel transformModel = QColorSpace::TransformModel::ThreeComponentMatrix; + QColorSpace::ColorModel colorModel = QColorSpace::ColorModel::Undefined; float gamma = 0.0f; QColorVector whitePoint; + // Three component matrix data: QColorTrc trc[3]; QColorMatrix toXyz; - + QColorMatrix chad; + + // Element list processing data: + struct TransferElement { + QColorTrc trc[4]; + }; + using Element = std::variant<TransferElement, QColorMatrix, QColorVector, QColorCLUT>; + bool isPcsLab = false; + // A = device, B = PCS + QList<Element> mAB, mBA; + + // Metadata QString description; QString userDescription; QByteArray iccProfile; - static QBasicMutex s_lutWriteLock; + // Cached tables for three component matrix transform: + Q_CONSTINIT static QBasicMutex s_lutWriteLock; struct LUT { LUT() = default; ~LUT() = default; diff --git a/src/gui/painting/qcolortransferfunction_p.h b/src/gui/painting/qcolortransferfunction_p.h index a9bb26df59..484cc69114 100644 --- a/src/gui/painting/qcolortransferfunction_p.h +++ b/src/gui/painting/qcolortransferfunction_p.h @@ -16,44 +16,52 @@ // #include <QtGui/private/qtguiglobal_p.h> +#include <QtCore/QFlags> #include <cmath> QT_BEGIN_NAMESPACE // Defines a ICC parametric curve type 4 -class Q_GUI_EXPORT QColorTransferFunction +class QColorTransferFunction { public: QColorTransferFunction() noexcept - : m_a(1.0f), m_b(0.0f), m_c(1.0f), m_d(0.0f), m_e(0.0f), m_f(0.0f), m_g(1.0f), m_flags(0) + : m_a(1.0f), m_b(0.0f), m_c(1.0f), m_d(0.0f), m_e(0.0f), m_f(0.0f), m_g(1.0f) + , m_flags(Hints(Hint::Calculated) | Hint::IsGamma | Hint::IsIdentity) { } + QColorTransferFunction(float a, float b, float c, float d, float e, float f, float g) noexcept - : m_a(a), m_b(b), m_c(c), m_d(d), m_e(e), m_f(f), m_g(g), m_flags(0) + : m_a(a), m_b(b), m_c(c), m_d(d), m_e(e), m_f(f), m_g(g), m_flags() { } bool isGamma() const { updateHints(); - return m_flags & quint32(Hints::IsGamma); + return m_flags & Hint::IsGamma; } - bool isLinear() const + bool isIdentity() const { updateHints(); - return m_flags & quint32(Hints::IsLinear); + return m_flags & Hint::IsIdentity; } bool isSRgb() const { updateHints(); - return m_flags & quint32(Hints::IsSRgb); + return m_flags & Hint::IsSRgb; } float apply(float x) const { if (x < m_d) return m_c * x + m_f; + float t = std::pow(m_a * x + m_b, m_g); + if (std::isfinite(t)) + return t + m_e; + if (t > 0.f) + return 1.f; else - return std::pow(m_a * x + m_b, m_g) + m_e; + return 0.f; } QColorTransferFunction inverted() const @@ -62,7 +70,7 @@ public: d = m_c * m_d + m_f; - if (!qFuzzyIsNull(m_c)) { + if (std::isnormal(m_c)) { c = 1.0f / m_c; f = -m_f / m_c; } else { @@ -70,8 +78,12 @@ public: f = 0.0f; } - if (!qFuzzyIsNull(m_a) && !qFuzzyIsNull(m_g)) { + bool valid_abeg = std::isnormal(m_a) && std::isnormal(m_g); + if (valid_abeg) a = std::pow(1.0f / m_a, m_g); + if (valid_abeg && !std::isfinite(a)) + valid_abeg = false; + if (valid_abeg) { b = -a * m_e; e = -m_b / m_a; g = 1.0f / m_g; @@ -88,15 +100,19 @@ public: // A few predefined curves: static QColorTransferFunction fromGamma(float gamma) { - return QColorTransferFunction(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, gamma); + return QColorTransferFunction(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, gamma, + Hints(Hint::Calculated) | Hint::IsGamma | + (paramCompare(gamma, 1.0f) ? Hint::IsIdentity : Hint::NoHint)); } static QColorTransferFunction fromSRgb() { - return QColorTransferFunction(1.0f / 1.055f, 0.055f / 1.055f, 1.0f / 12.92f, 0.04045f, 0.0f, 0.0f, 2.4f); + return QColorTransferFunction(1.0f / 1.055f, 0.055f / 1.055f, 1.0f / 12.92f, 0.04045f, 0.0f, 0.0f, 2.4f, + Hints(Hint::Calculated) | Hint::IsSRgb); } static QColorTransferFunction fromProPhotoRgb() { - return QColorTransferFunction(1.0f, 0.0f, 1.0f / 16.0f, 16.0f / 512.0f, 0.0f, 0.0f, 1.8f); + return QColorTransferFunction(1.0f, 0.0f, 1.0f / 16.0f, 16.0f / 512.0f, 0.0f, 0.0f, 1.8f, + Hints(Hint::Calculated)); } bool matches(const QColorTransferFunction &o) const { @@ -116,7 +132,20 @@ public: float m_f; float m_g; + enum class Hint : quint32 { + NoHint = 0, + Calculated = 1, + IsGamma = 2, + IsIdentity = 4, + IsSRgb = 8 + }; + + Q_DECLARE_FLAGS(Hints, Hint); + private: + QColorTransferFunction(float a, float b, float c, float d, float e, float f, float g, Hints flags) noexcept + : m_a(a), m_b(b), m_c(c), m_d(d), m_e(e), m_f(f), m_g(g), m_flags(flags) + { } static inline bool paramCompare(float p1, float p2) { // Much fuzzier than fuzzy compare. @@ -127,7 +156,7 @@ private: void updateHints() const { - if (m_flags & quint32(Hints::Calculated)) + if (m_flags & Hint::Calculated) return; // We do not consider the case with m_d = 1.0f linear or simple, // since it wouldn't be linear for applyExtended(). @@ -135,24 +164,21 @@ private: && paramCompare(m_d, 0.0f) && paramCompare(m_e, 0.0f); if (simple) { - m_flags |= quint32(Hints::IsGamma); + m_flags |= Hint::IsGamma; if (qFuzzyCompare(m_g, 1.0f)) - m_flags |= quint32(Hints::IsLinear); + m_flags |= Hint::IsIdentity; } else { if (*this == fromSRgb()) - m_flags |= quint32(Hints::IsSRgb); + m_flags |= Hint::IsSRgb; } - m_flags |= quint32(Hints::Calculated); + m_flags |= Hint::Calculated; } - enum class Hints : quint32 { - Calculated = 1, - IsGamma = 2, - IsLinear = 4, - IsSRgb = 8 - }; - mutable quint32 m_flags; + + mutable Hints m_flags; }; +Q_DECLARE_OPERATORS_FOR_FLAGS(QColorTransferFunction::Hints); + inline bool operator==(const QColorTransferFunction &f1, const QColorTransferFunction &f2) { return f1.matches(f2); diff --git a/src/gui/painting/qcolortransfertable_p.h b/src/gui/painting/qcolortransfertable_p.h index ac1f843912..ce6ad0c4b2 100644 --- a/src/gui/painting/qcolortransfertable_p.h +++ b/src/gui/painting/qcolortransfertable_p.h @@ -29,25 +29,38 @@ QT_BEGIN_NAMESPACE class Q_GUI_EXPORT QColorTransferTable { public: - QColorTransferTable() noexcept - : m_tableSize(0) - { } - QColorTransferTable(uint32_t size, const QList<uint8_t> &table) noexcept - : m_tableSize(size), m_table8(table) + enum Type : uint8_t { + TwoWay = 0, + OneWay, + }; + QColorTransferTable() noexcept = default; + QColorTransferTable(uint32_t size, const QList<uint8_t> &table, Type type = TwoWay) noexcept + : m_type(type), m_tableSize(size), m_table8(table) { - Q_ASSERT(qsizetype(size) <= table.count()); + Q_ASSERT(qsizetype(size) <= table.size()); } - QColorTransferTable(uint32_t size, const QList<uint16_t> &table) noexcept - : m_tableSize(size), m_table16(table) + QColorTransferTable(uint32_t size, const QList<uint16_t> &table, Type type = TwoWay) noexcept + : m_type(type), m_tableSize(size), m_table16(table) { - Q_ASSERT(qsizetype(size) <= table.count()); + Q_ASSERT(qsizetype(size) <= table.size()); } - bool isEmpty() const + bool isEmpty() const noexcept { return m_tableSize == 0; } + bool isIdentity() const + { + if (isEmpty()) + return true; + if (m_tableSize != 2) + return false; + if (!m_table8.isEmpty()) + return m_table8[0] == 0 && m_table8[1] == 255; + return m_table16[0] == 0 && m_table16[1] == 65535; + } + bool checkValidity() const { if (isEmpty()) @@ -58,7 +71,11 @@ public: // At least 2 elements if (m_tableSize < 2) return false; - // The table must describe an injective curve: + return (m_type == OneWay) || checkInvertibility(); + } + bool checkInvertibility() const + { + // The two-way tables must describe an injective curve: if (!m_table8.isEmpty()) { uint8_t val = 0; for (uint i = 0; i < m_tableSize; ++i) { @@ -80,15 +97,17 @@ public: float apply(float x) const { + if (isEmpty()) + return x; x = std::clamp(x, 0.0f, 1.0f); x *= m_tableSize - 1; - const uint32_t lo = static_cast<uint32_t>(std::floor(x)); + const uint32_t lo = static_cast<uint32_t>(x); const uint32_t hi = std::min(lo + 1, m_tableSize - 1); const float frac = x - lo; if (!m_table16.isEmpty()) - return (m_table16[lo] * (1.0f - frac) + m_table16[hi] * frac) * (1.0f/65535.0f); + return (m_table16[lo] + (m_table16[hi] - m_table16[lo]) * frac) * (1.0f/65535.0f); if (!m_table8.isEmpty()) - return (m_table8[lo] * (1.0f - frac) + m_table8[hi] * frac) * (1.0f/255.0f); + return (m_table8[lo] + (m_table8[hi] - m_table8[lo]) * frac) * (1.0f/255.0f); return x; } @@ -96,43 +115,25 @@ public: float applyInverse(float x, float resultLargerThan = 0.0f) const { Q_ASSERT(resultLargerThan >= 0.0f && resultLargerThan <= 1.0f); + Q_ASSERT(m_type == TwoWay); if (x <= 0.0f) return 0.0f; if (x >= 1.0f) return 1.0f; - if (!m_table16.isEmpty()) { - const float v = x * 65535.0f; - uint32_t i = static_cast<uint32_t>(std::floor(resultLargerThan * (m_tableSize - 1))); - auto it = std::lower_bound(m_table16.cbegin() + i, m_table16.cend(), v); - i = it - m_table16.cbegin(); - if (i >= m_tableSize - 1) - return 1.0f; - const float y1 = m_table16[i - 1]; - const float y2 = m_table16[i]; - Q_ASSERT(v >= y1 && v <= y2); - const float fr = (v - y1) / (y2 - y1); - return (i + fr) * (1.0f / (m_tableSize - 1)); - - } - if (!m_table8.isEmpty()) { - const float v = x * 255.0f; - uint32_t i = static_cast<uint32_t>(std::floor(resultLargerThan * (m_tableSize - 1))); - auto it = std::lower_bound(m_table8.cbegin() + i, m_table8.cend(), v); - i = it - m_table8.cbegin(); - if (i >= m_tableSize - 1) - return 1.0f; - const float y1 = m_table8[i - 1]; - const float y2 = m_table8[i]; - Q_ASSERT(v >= y1 && v <= y2); - const float fr = (v - y1) / (y2 - y1); - return (i + fr) * (1.0f / (m_tableSize - 1)); - } + if (!m_table16.isEmpty()) + return inverseLookup(x * 65535.0f, resultLargerThan, m_table16, m_tableSize - 1); + if (!m_table8.isEmpty()) + return inverseLookup(x * 255.0f, resultLargerThan, m_table8, m_tableSize - 1); return x; } bool asColorTransferFunction(QColorTransferFunction *transferFn) { Q_ASSERT(transferFn); + if (isEmpty()) { + *transferFn = QColorTransferFunction(); + return true; + } if (m_tableSize < 2) return false; if (!m_table8.isEmpty() && (m_table8[0] != 0 || m_table8[m_tableSize - 1] != 255)) @@ -182,15 +183,36 @@ public: friend inline bool operator!=(const QColorTransferTable &t1, const QColorTransferTable &t2); friend inline bool operator==(const QColorTransferTable &t1, const QColorTransferTable &t2); - uint32_t m_tableSize; + Type m_type = TwoWay; + uint32_t m_tableSize = 0; QList<uint8_t> m_table8; QList<uint16_t> m_table16; +private: + template<typename T> + static float inverseLookup(float needle, float resultLargerThan, const QList<T> &table, quint32 tableMax) + { + uint32_t i = static_cast<uint32_t>(resultLargerThan * tableMax); + auto it = std::lower_bound(table.cbegin() + i, table.cend(), needle); + i = it - table.cbegin(); + if (i == 0) + return 0.0f; + if (i >= tableMax) + return 1.0f; + const float y1 = table[i - 1]; + const float y2 = table[i]; + Q_ASSERT(needle >= y1 && needle <= y2); + const float fr = (needle - y1) / (y2 - y1); + return (i + fr) * (1.0f / tableMax); + } + }; inline bool operator!=(const QColorTransferTable &t1, const QColorTransferTable &t2) { if (t1.m_tableSize != t2.m_tableSize) return true; + if (t1.m_type != t2.m_type) + return true; if (t1.m_table8.isEmpty() != t2.m_table8.isEmpty()) return true; if (t1.m_table16.isEmpty() != t2.m_table16.isEmpty()) diff --git a/src/gui/painting/qcolortransform.cpp b/src/gui/painting/qcolortransform.cpp index ff7229e060..aac07bdc09 100644 --- a/src/gui/painting/qcolortransform.cpp +++ b/src/gui/painting/qcolortransform.cpp @@ -1,10 +1,11 @@ -// Copyright (C) 2018 The Qt Company Ltd. +// Copyright (C) 2024 The Qt Company Ltd. // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only - #include "qcolortransform.h" #include "qcolortransform_p.h" +#include "qcmyk_p.h" +#include "qcolorclut_p.h" #include "qcolormatrix_p.h" #include "qcolorspace_p.h" #include "qcolortrc_p.h" @@ -13,6 +14,7 @@ #include <QtCore/qatomic.h> #include <QtCore/qmath.h> #include <QtGui/qcolor.h> +#include <QtGui/qimage.h> #include <QtGui/qtransform.h> #include <QtCore/private/qsimd_p.h> @@ -105,6 +107,70 @@ QColorTransform::~QColorTransform() = default; QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QColorTransformPrivate) /*! + \since 6.4 + Returns true if the color transform is the identity transform. +*/ +bool QColorTransform::isIdentity() const noexcept +{ + return !d || d->isIdentity(); +} + +/*! + \fn bool QColorTransform::operator==(const QColorTransform &ct1, const QColorTransform &ct2) + \since 6.4 + Returns true if \a ct1 defines the same color transformation as \a ct2. +*/ + +/*! + \fn bool QColorTransform::operator!=(const QColorTransform &ct1, const QColorTransform &ct2) + \since 6.4 + Returns true if \a ct1 does not define the same transformation as \a ct2. +*/ + +/*! \internal +*/ +bool QColorTransform::compare(const QColorTransform &other) const +{ + if (d == other.d) + return true; + if (bool(d) != bool(other.d)) + return d ? d->isIdentity() : other.d->isIdentity(); + if (d->colorMatrix != other.d->colorMatrix) + return false; + if (bool(d->colorSpaceIn) != bool(other.d->colorSpaceIn)) + return false; + if (bool(d->colorSpaceOut) != bool(other.d->colorSpaceOut)) + return false; + if (d->colorSpaceIn) { + if (d->colorSpaceIn->transformModel != other.d->colorSpaceIn->transformModel) + return false; + if (d->colorSpaceIn->isThreeComponentMatrix()) { + for (int i = 0; i < 3; ++i) { + if (d->colorSpaceIn && d->colorSpaceIn->trc[i] != other.d->colorSpaceIn->trc[i]) + return false; + } + } else { + if (!d->colorSpaceIn->equals(other.d->colorSpaceIn.constData())) + return false; + } + } + if (d->colorSpaceOut) { + if (d->colorSpaceOut->transformModel != other.d->colorSpaceOut->transformModel) + return false; + if (d->colorSpaceOut->isThreeComponentMatrix()) { + for (int i = 0; i < 3; ++i) { + if (d->colorSpaceOut && d->colorSpaceOut->trc[i] != other.d->colorSpaceOut->trc[i]) + return false; + } + } else { + if (!d->colorSpaceOut->equals(other.d->colorSpaceOut.constData())) + return false; + } + } + return true; +} + +/*! Applies the color transformation on the QRgb value \a argb. The input should be opaque or unpremultiplied. @@ -115,23 +181,7 @@ QRgb QColorTransform::map(QRgb argb) const return argb; constexpr float f = 1.0f / 255.0f; QColorVector c = { qRed(argb) * f, qGreen(argb) * f, qBlue(argb) * f }; - c.x = d->colorSpaceIn->trc[0].apply(c.x); - c.y = d->colorSpaceIn->trc[1].apply(c.y); - c.z = d->colorSpaceIn->trc[2].apply(c.z); - c = d->colorMatrix.map(c); - c.x = std::max(0.0f, std::min(1.0f, c.x)); - c.y = std::max(0.0f, std::min(1.0f, c.y)); - c.z = std::max(0.0f, std::min(1.0f, c.z)); - if (d->colorSpaceOut->lut.generated.loadAcquire()) { - c.x = d->colorSpaceOut->lut[0]->fromLinear(c.x); - c.y = d->colorSpaceOut->lut[1]->fromLinear(c.y); - c.z = d->colorSpaceOut->lut[2]->fromLinear(c.z); - } else { - c.x = d->colorSpaceOut->trc[0].applyInverse(c.x); - c.y = d->colorSpaceOut->trc[1].applyInverse(c.y); - c.z = d->colorSpaceOut->trc[2].applyInverse(c.z); - } - + c = d->map(c); return qRgba(c.x * 255 + 0.5f, c.y * 255 + 0.5f, c.z * 255 + 0.5f, qAlpha(argb)); } @@ -146,24 +196,44 @@ QRgba64 QColorTransform::map(QRgba64 rgba64) const return rgba64; constexpr float f = 1.0f / 65535.0f; QColorVector c = { rgba64.red() * f, rgba64.green() * f, rgba64.blue() * f }; - c.x = d->colorSpaceIn->trc[0].apply(c.x); - c.y = d->colorSpaceIn->trc[1].apply(c.y); - c.z = d->colorSpaceIn->trc[2].apply(c.z); - c = d->colorMatrix.map(c); - c.x = std::max(0.0f, std::min(1.0f, c.x)); - c.y = std::max(0.0f, std::min(1.0f, c.y)); - c.z = std::max(0.0f, std::min(1.0f, c.z)); - if (d->colorSpaceOut->lut.generated.loadAcquire()) { - c.x = d->colorSpaceOut->lut[0]->fromLinear(c.x); - c.y = d->colorSpaceOut->lut[1]->fromLinear(c.y); - c.z = d->colorSpaceOut->lut[2]->fromLinear(c.z); - } else { - c.x = d->colorSpaceOut->trc[0].applyInverse(c.x); - c.y = d->colorSpaceOut->trc[1].applyInverse(c.y); - c.z = d->colorSpaceOut->trc[2].applyInverse(c.z); - } + c = d->map(c); + return QRgba64::fromRgba64(c.x * 65535.f + 0.5f, c.y * 65535.f + 0.5f, c.z * 65535.f + 0.5f, rgba64.alpha()); +} - return QRgba64::fromRgba64(c.x * 65535, c.y * 65535, c.z * 65535, rgba64.alpha()); +/*! + Applies the color transformation on the QRgbaFloat16 value \a rgbafp16. + + The input should be opaque or unpremultiplied. + \since 6.4 +*/ +QRgbaFloat16 QColorTransform::map(QRgbaFloat16 rgbafp16) const +{ + if (!d) + return rgbafp16; + QColorVector c(rgbafp16.r, rgbafp16.g, rgbafp16.b); + c = d->mapExtended(c); + rgbafp16.r = qfloat16(c.x); + rgbafp16.g = qfloat16(c.y); + rgbafp16.b = qfloat16(c.z); + return rgbafp16; +} + +/*! + Applies the color transformation on the QRgbaFloat32 value \a rgbafp32. + + The input should be opaque or unpremultiplied. + \since 6.4 +*/ +QRgbaFloat32 QColorTransform::map(QRgbaFloat32 rgbafp32) const +{ + if (!d) + return rgbafp32; + QColorVector c(rgbafp32.r, rgbafp32.g, rgbafp32.b); + c = d->mapExtended(c); + rgbafp32.r = c.x; + rgbafp32.g = c.y; + rgbafp32.b = c.z; + return rgbafp32; } /*! @@ -175,44 +245,42 @@ QColor QColorTransform::map(const QColor &color) const if (!d) return color; QColor clr = color; - if (color.spec() != QColor::ExtendedRgb || color.spec() != QColor::Rgb) - clr = clr.toRgb(); - - QColorVector c = { (float)clr.redF(), (float)clr.greenF(), (float)clr.blueF() }; - if (clr.spec() == QColor::ExtendedRgb) { - c.x = d->colorSpaceIn->trc[0].applyExtended(c.x); - c.y = d->colorSpaceIn->trc[1].applyExtended(c.y); - c.z = d->colorSpaceIn->trc[2].applyExtended(c.z); - } else { - c.x = d->colorSpaceIn->trc[0].apply(c.x); - c.y = d->colorSpaceIn->trc[1].apply(c.y); - c.z = d->colorSpaceIn->trc[2].apply(c.z); - } - c = d->colorMatrix.map(c); - bool inGamut = c.x >= 0.0f && c.x <= 1.0f && c.y >= 0.0f && c.y <= 1.0f && c.z >= 0.0f && c.z <= 1.0f; - if (inGamut) { - if (d->colorSpaceOut->lut.generated.loadAcquire()) { - c.x = d->colorSpaceOut->lut[0]->fromLinear(c.x); - c.y = d->colorSpaceOut->lut[1]->fromLinear(c.y); - c.z = d->colorSpaceOut->lut[2]->fromLinear(c.z); - } else { - c.x = d->colorSpaceOut->trc[0].applyInverse(c.x); - c.y = d->colorSpaceOut->trc[1].applyInverse(c.y); - c.z = d->colorSpaceOut->trc[2].applyInverse(c.z); - } - } else { - c.x = d->colorSpaceOut->trc[0].applyInverseExtended(c.x); - c.y = d->colorSpaceOut->trc[1].applyInverseExtended(c.y); - c.z = d->colorSpaceOut->trc[2].applyInverseExtended(c.z); + if (d->colorSpaceIn->colorModel == QColorSpace::ColorModel::Rgb) { + if (color.spec() != QColor::ExtendedRgb && color.spec() != QColor::Rgb) + clr = clr.toRgb(); + } else if (d->colorSpaceIn->colorModel == QColorSpace::ColorModel::Cmyk) { + if (color.spec() != QColor::Cmyk) + clr = clr.toCmyk(); } + + QColorVector c = + (clr.spec() == QColor::Cmyk) + ? QColorVector(clr.cyanF(), clr.magentaF(), clr.yellowF(), clr.blackF()) + : QColorVector(clr.redF(), clr.greenF(), clr.blueF()); + + c = d->mapExtended(c); + QColor out; - out.setRgbF(c.x, c.y, c.z, color.alphaF()); + if (d->colorSpaceOut->colorModel == QColorSpace::ColorModel::Cmyk) { + c.x = std::clamp(c.x, 0.f, 1.f); + c.y = std::clamp(c.y, 0.f, 1.f); + c.z = std::clamp(c.z, 0.f, 1.f); + c.w = std::clamp(c.w, 0.f, 1.f); + out.setCmykF(c.x, c.y, c.z, c.w, color.alphaF()); + } else { + out.setRgbF(c.x, c.y, c.z, color.alphaF()); + } return out; } // Optimized sub-routines for fast block based conversion: -template<bool DoClamp = true> +enum ApplyMatrixForm { + DoNotClamp = 0, + DoClamp = 1 +}; + +template<ApplyMatrixForm doClamp = DoClamp> static void applyMatrix(QColorVector *buffer, const qsizetype len, const QColorMatrix &colorMatrix) { #if defined(__SSE2__) @@ -232,7 +300,7 @@ static void applyMatrix(QColorVector *buffer, const qsizetype len, const QColorM cx = _mm_add_ps(cx, cy); cx = _mm_add_ps(cx, cz); // Clamp: - if (DoClamp) { + if (doClamp) { cx = _mm_min_ps(cx, maxV); cx = _mm_max_ps(cx, minV); } @@ -252,19 +320,19 @@ static void applyMatrix(QColorVector *buffer, const qsizetype len, const QColorM cx = vaddq_f32(cx, cy); cx = vaddq_f32(cx, cz); // Clamp: - if (DoClamp) { + if (doClamp) { cx = vminq_f32(cx, maxV); cx = vmaxq_f32(cx, minV); } vst1q_f32(&buffer[j].x, cx); } #else - for (int j = 0; j < len; ++j) { + for (qsizetype j = 0; j < len; ++j) { const QColorVector cv = colorMatrix.map(buffer[j]); - if (DoClamp) { - buffer[j].x = std::max(0.0f, std::min(1.0f, cv.x)); - buffer[j].y = std::max(0.0f, std::min(1.0f, cv.y)); - buffer[j].z = std::max(0.0f, std::min(1.0f, cv.z)); + if (doClamp) { + buffer[j].x = std::clamp(cv.x, 0.f, 1.f); + buffer[j].y = std::clamp(cv.y, 0.f, 1.f); + buffer[j].z = std::clamp(cv.z, 0.f, 1.f); } else { buffer[j] = cv; } @@ -272,6 +340,39 @@ static void applyMatrix(QColorVector *buffer, const qsizetype len, const QColorM #endif } +template<ApplyMatrixForm doClamp = DoClamp> +static void clampIfNeeded(QColorVector *buffer, const qsizetype len) +{ + if constexpr (doClamp != DoClamp) + return; +#if defined(__SSE2__) + const __m128 minV = _mm_set1_ps(0.0f); + const __m128 maxV = _mm_set1_ps(1.0f); + for (qsizetype j = 0; j < len; ++j) { + __m128 c = _mm_loadu_ps(&buffer[j].x); + c = _mm_min_ps(c, maxV); + c = _mm_max_ps(c, minV); + _mm_storeu_ps(&buffer[j].x, c); + } +#elif defined(__ARM_NEON__) + const float32x4_t minV = vdupq_n_f32(0.0f); + const float32x4_t maxV = vdupq_n_f32(1.0f); + for (qsizetype j = 0; j < len; ++j) { + float32x4_t c = vld1q_f32(&buffer[j].x); + c = vminq_f32(c, maxV); + c = vmaxq_f32(c, minV); + vst1q_f32(&buffer[j].x, c); + } +#else + for (qsizetype j = 0; j < len; ++j) { + const QColorVector cv = buffer[j]; + buffer[j].x = std::clamp(cv.x, 0.f, 1.f); + buffer[j].y = std::clamp(cv.y, 0.f, 1.f); + buffer[j].z = std::clamp(cv.z, 0.f, 1.f); + } +#endif +} + #if defined(__SSE2__) || defined(__ARM_NEON__) template<typename T> static constexpr inline bool isArgb(); @@ -288,9 +389,29 @@ inline int getAlpha<QRgb>(const QRgb &p) template<> inline int getAlpha<QRgba64>(const QRgba64 &p) { return p.alpha(); } + #endif template<typename T> +static float getAlphaF(const T &); +template<> float getAlphaF(const QRgb &r) +{ + return qAlpha(r) * (1.f / 255.f); +} +template<> float getAlphaF(const QCmyk32 &) +{ + return 1.f; +} +template<> float getAlphaF(const QRgba64 &r) +{ + return r.alpha() * (1.f / 65535.f); +} +template<> float getAlphaF(const QRgbaFloat32 &r) +{ + return r.a; +} + +template<typename T> static void loadPremultiplied(QColorVector *buffer, const T *src, const qsizetype len, const QColorTransformPrivate *d_ptr); template<typename T> static void loadUnpremultiplied(QColorVector *buffer, const T *src, const qsizetype len, const QColorTransformPrivate *d_ptr); @@ -326,7 +447,7 @@ inline void loadP<QRgba64>(const QRgba64 &p, __m128i &v) template<typename T> static void loadPremultiplied(QColorVector *buffer, const T *src, const qsizetype len, const QColorTransformPrivate *d_ptr) { - const __m128 v4080 = _mm_set1_ps(4080.f); + const __m128 vTrcRes = _mm_set1_ps(float(QColorTrcLut::Resolution)); const __m128 iFF00 = _mm_set1_ps(1.0f / (255 * 256)); constexpr bool isARGB = isArgb<T>(); for (qsizetype i = 0; i < len; ++i) { @@ -345,7 +466,7 @@ static void loadPremultiplied(QColorVector *buffer, const T *src, const qsizetyp vf = _mm_andnot_ps(vAlphaMask, vf); // LUT - v = _mm_cvtps_epi32(_mm_mul_ps(vf, v4080)); + v = _mm_cvtps_epi32(_mm_mul_ps(vf, vTrcRes)); const int ridx = isARGB ? _mm_extract_epi16(v, 4) : _mm_extract_epi16(v, 0); const int gidx = _mm_extract_epi16(v, 2); const int bidx = isARGB ? _mm_extract_epi16(v, 0) : _mm_extract_epi16(v, 4); @@ -361,7 +482,7 @@ static void loadPremultiplied(QColorVector *buffer, const T *src, const qsizetyp template<> void loadPremultiplied<QRgbaFloat32>(QColorVector *buffer, const QRgbaFloat32 *src, const qsizetype len, const QColorTransformPrivate *d_ptr) { - const __m128 v4080 = _mm_set1_ps(4080.f); + const __m128 vTrcRes = _mm_set1_ps(float(QColorTrcLut::Resolution)); const __m128 viFF00 = _mm_set1_ps(1.0f / (255 * 256)); const __m128 vZero = _mm_set1_ps(0.0f); const __m128 vOne = _mm_set1_ps(1.0f); @@ -383,7 +504,7 @@ void loadPremultiplied<QRgbaFloat32>(QColorVector *buffer, const QRgbaFloat32 *s const __m128 over = _mm_cmpgt_ps(vf, vOne); if (_mm_movemask_ps(_mm_or_ps(under, over)) == 0) { // Within gamut - __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, v4080)); + __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, vTrcRes)); const int ridx = _mm_extract_epi16(v, 0); const int gidx = _mm_extract_epi16(v, 2); const int bidx = _mm_extract_epi16(v, 4); @@ -402,7 +523,7 @@ void loadPremultiplied<QRgbaFloat32>(QColorVector *buffer, const QRgbaFloat32 *s } } -// Load to [0-4080] in 4x32 SIMD +// Load to [0->TrcResolution] in 4x32 SIMD template<typename T> static inline void loadPU(const T &p, __m128i &v); @@ -416,7 +537,7 @@ inline void loadPU<QRgb>(const QRgb &p, __m128i &v) v = _mm_unpacklo_epi8(v, _mm_setzero_si128()); v = _mm_unpacklo_epi16(v, _mm_setzero_si128()); #endif - v = _mm_slli_epi32(v, 4); + v = _mm_slli_epi32(v, QColorTrcLut::ShiftUp); } template<> @@ -429,7 +550,7 @@ inline void loadPU<QRgba64>(const QRgba64 &p, __m128i &v) #else v = _mm_unpacklo_epi16(v, _mm_setzero_si128()); #endif - v = _mm_srli_epi32(v, 4); + v = _mm_srli_epi32(v, QColorTrcLut::ShiftDown); } template<typename T> @@ -454,7 +575,7 @@ void loadUnpremultiplied(QColorVector *buffer, const T *src, const qsizetype len template<> void loadUnpremultiplied<QRgbaFloat32>(QColorVector *buffer, const QRgbaFloat32 *src, const qsizetype len, const QColorTransformPrivate *d_ptr) { - const __m128 v4080 = _mm_set1_ps(4080.f); + const __m128 vTrcRes = _mm_set1_ps(float(QColorTrcLut::Resolution)); const __m128 iFF00 = _mm_set1_ps(1.0f / (255 * 256)); const __m128 vZero = _mm_set1_ps(0.0f); const __m128 vOne = _mm_set1_ps(1.0f); @@ -464,7 +585,7 @@ void loadUnpremultiplied<QRgbaFloat32>(QColorVector *buffer, const QRgbaFloat32 const __m128 over = _mm_cmpgt_ps(vf, vOne); if (_mm_movemask_ps(_mm_or_ps(under, over)) == 0) { // Within gamut - __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, v4080)); + __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, vTrcRes)); const int ridx = _mm_extract_epi16(v, 0); const int gidx = _mm_extract_epi16(v, 2); const int bidx = _mm_extract_epi16(v, 4); @@ -525,7 +646,7 @@ static void loadPremultiplied(QColorVector *buffer, const T *src, const qsizetyp vf = vreinterpretq_f32_u32(vbicq_u32(vreinterpretq_u32_f32(vf), vAlphaMask)); // LUT - v = vcvtq_u32_f32(vaddq_f32(vmulq_n_f32(vf, 4080.f), vdupq_n_f32(0.5f))); + v = vcvtq_u32_f32(vaddq_f32(vmulq_n_f32(vf, float(QColorTrcLut::Resolution)), vdupq_n_f32(0.5f))); const int ridx = isARGB ? vgetq_lane_u32(v, 2) : vgetq_lane_u32(v, 0); const int gidx = vgetq_lane_u32(v, 1); const int bidx = isARGB ? vgetq_lane_u32(v, 0) : vgetq_lane_u32(v, 2); @@ -538,7 +659,7 @@ static void loadPremultiplied(QColorVector *buffer, const T *src, const qsizetyp } } -// Load to [0-4080] in 4x32 SIMD +// Load to [0->TrcResultion] in 4x32 SIMD template<typename T> static inline void loadPU(const T &p, uint32x4_t &v); @@ -546,7 +667,7 @@ template<> inline void loadPU<QRgb>(const QRgb &p, uint32x4_t &v) { v = vmovl_u16(vget_low_u16(vmovl_u8(vreinterpret_u8_u32(vmov_n_u32(p))))); - v = vshlq_n_u32(v, 4); + v = vshlq_n_u32(v, QColorTrcLut::ShiftUp); } template<> @@ -555,7 +676,7 @@ inline void loadPU<QRgba64>(const QRgba64 &p, uint32x4_t &v) uint16x4_t v16 = vreinterpret_u16_u64(vld1_u64(reinterpret_cast<const uint64_t *>(&p))); v16 = vsub_u16(v16, vshr_n_u16(v16, 8)); v = vmovl_u16(v16); - v = vshrq_n_u32(v, 4); + v = vshrq_n_u32(v, QColorTrcLut::ShiftDown); } template<typename T> @@ -584,7 +705,7 @@ void loadPremultiplied<QRgb>(QColorVector *buffer, const QRgb *src, const qsizet const uint p = src[i]; const int a = qAlpha(p); if (a) { - const float ia = 4080.0f / a; + const float ia = float(QColorTrcLut::Resolution) / a; const int ridx = int(qRed(p) * ia + 0.5f); const int gidx = int(qGreen(p) * ia + 0.5f); const int bidx = int(qBlue(p) * ia + 0.5f); @@ -604,7 +725,7 @@ void loadPremultiplied<QRgba64>(QColorVector *buffer, const QRgba64 *src, const const QRgba64 &p = src[i]; const int a = p.alpha(); if (a) { - const float ia = 4080.0f / a; + const float ia = float(QColorTrcLut::Resolution) / a; const int ridx = int(p.red() * ia + 0.5f); const int gidx = int(p.green() * ia + 0.5f); const int bidx = int(p.blue() * ia + 0.5f); @@ -694,17 +815,18 @@ inline void storeP<QRgba64>(QRgba64 &p, __m128i &v, int a) #endif } -template<typename T> -static void storePremultiplied(T *dst, const T *src, const QColorVector *buffer, const qsizetype len, +template<typename D, typename S, + typename = std::enable_if_t<!std::is_same_v<D, QRgbaFloat32>, void>> +static void storePremultiplied(D *dst, const S *src, const QColorVector *buffer, const qsizetype len, const QColorTransformPrivate *d_ptr) { - const __m128 v4080 = _mm_set1_ps(4080.f); + const __m128 vTrcRes = _mm_set1_ps(float(QColorTrcLut::Resolution)); const __m128 iFF00 = _mm_set1_ps(1.0f / (255 * 256)); - constexpr bool isARGB = isArgb<T>(); + constexpr bool isARGB = isArgb<D>(); for (qsizetype i = 0; i < len; ++i) { - const int a = getAlpha<T>(src[i]); + const int a = getAlpha<S>(src[i]); __m128 vf = _mm_loadu_ps(&buffer[i].x); - __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, v4080)); + __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, vTrcRes)); __m128 va = _mm_mul_ps(_mm_set1_ps(a), iFF00); const int ridx = _mm_extract_epi16(v, 0); const int gidx = _mm_extract_epi16(v, 2); @@ -715,21 +837,21 @@ static void storePremultiplied(T *dst, const T *src, const QColorVector *buffer, vf = _mm_cvtepi32_ps(v); vf = _mm_mul_ps(vf, va); v = _mm_cvtps_epi32(vf); - storeP<T>(dst[i], v, a); + storeP<D>(dst[i], v, a); } } -template<> -void storePremultiplied<QRgbaFloat32>(QRgbaFloat32 *dst, const QRgbaFloat32 *src, - const QColorVector *buffer, const qsizetype len, - const QColorTransformPrivate *d_ptr) +template<typename S> +static void storePremultiplied(QRgbaFloat32 *dst, const S *src, + const QColorVector *buffer, const qsizetype len, + const QColorTransformPrivate *d_ptr) { - const __m128 v4080 = _mm_set1_ps(4080.f); + const __m128 vTrcRes = _mm_set1_ps(float(QColorTrcLut::Resolution)); const __m128 vZero = _mm_set1_ps(0.0f); const __m128 vOne = _mm_set1_ps(1.0f); const __m128 viFF00 = _mm_set1_ps(1.0f / (255 * 256)); for (qsizetype i = 0; i < len; ++i) { - const float a = src[i].a; + const float a = getAlphaF<S>(src[i]); __m128 va = _mm_set1_ps(a); __m128 vf = _mm_loadu_ps(&buffer[i].x); const __m128 under = _mm_cmplt_ps(vf, vZero); @@ -737,7 +859,7 @@ void storePremultiplied<QRgbaFloat32>(QRgbaFloat32 *dst, const QRgbaFloat32 *src if (_mm_movemask_ps(_mm_or_ps(under, over)) == 0) { // Within gamut va = _mm_mul_ps(va, viFF00); - __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, v4080)); + __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, vTrcRes)); const int ridx = _mm_extract_epi16(v, 0); const int gidx = _mm_extract_epi16(v, 2); const int bidx = _mm_extract_epi16(v, 4); @@ -776,16 +898,17 @@ inline void storePU<QRgba64>(QRgba64 &p, __m128i &v, int a) _mm_storel_epi64((__m128i *)&p, v); } -template<typename T> -static void storeUnpremultiplied(T *dst, const T *src, const QColorVector *buffer, const qsizetype len, +template<typename D, typename S, + typename = std::enable_if_t<!std::is_same_v<D, QRgbaFloat32>, void>> +static void storeUnpremultiplied(D *dst, const S *src, const QColorVector *buffer, const qsizetype len, const QColorTransformPrivate *d_ptr) { - const __m128 v4080 = _mm_set1_ps(4080.f); - constexpr bool isARGB = isArgb<T>(); + const __m128 vTrcRes = _mm_set1_ps(float(QColorTrcLut::Resolution)); + constexpr bool isARGB = isArgb<D>(); for (qsizetype i = 0; i < len; ++i) { - const int a = getAlpha<T>(src[i]); + const int a = getAlpha<S>(src[i]); __m128 vf = _mm_loadu_ps(&buffer[i].x); - __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, v4080)); + __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, vTrcRes)); const int ridx = _mm_extract_epi16(v, 0); const int gidx = _mm_extract_epi16(v, 2); const int bidx = _mm_extract_epi16(v, 4); @@ -793,27 +916,27 @@ static void storeUnpremultiplied(T *dst, const T *src, const QColorVector *buffe v = _mm_insert_epi16(v, d_ptr->colorSpaceOut->lut[0]->m_fromLinear[ridx], isARGB ? 2 : 0); v = _mm_insert_epi16(v, d_ptr->colorSpaceOut->lut[1]->m_fromLinear[gidx], 1); v = _mm_insert_epi16(v, d_ptr->colorSpaceOut->lut[2]->m_fromLinear[bidx], isARGB ? 0 : 2); - storePU<T>(dst[i], v, a); + storePU<D>(dst[i], v, a); } } -template<> -void storeUnpremultiplied<QRgbaFloat32>(QRgbaFloat32 *dst, const QRgbaFloat32 *src, - const QColorVector *buffer, const qsizetype len, - const QColorTransformPrivate *d_ptr) +template<typename S> +void storeUnpremultiplied(QRgbaFloat32 *dst, const S *src, + const QColorVector *buffer, const qsizetype len, + const QColorTransformPrivate *d_ptr) { - const __m128 v4080 = _mm_set1_ps(4080.f); + const __m128 vTrcRes = _mm_set1_ps(float(QColorTrcLut::Resolution)); const __m128 vZero = _mm_set1_ps(0.0f); const __m128 vOne = _mm_set1_ps(1.0f); const __m128 viFF00 = _mm_set1_ps(1.0f / (255 * 256)); for (qsizetype i = 0; i < len; ++i) { - const float a = src[i].a; + const float a = getAlphaF<S>(src[i]); __m128 vf = _mm_loadu_ps(&buffer[i].x); const __m128 under = _mm_cmplt_ps(vf, vZero); const __m128 over = _mm_cmpgt_ps(vf, vOne); if (_mm_movemask_ps(_mm_or_ps(under, over)) == 0) { // Within gamut - __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, v4080)); + __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, vTrcRes)); const int ridx = _mm_extract_epi16(v, 0); const int gidx = _mm_extract_epi16(v, 2); const int bidx = _mm_extract_epi16(v, 4); @@ -833,15 +956,14 @@ void storeUnpremultiplied<QRgbaFloat32>(QRgbaFloat32 *dst, const QRgbaFloat32 *s } template<typename T> -static void storeOpaque(T *dst, const T *src, const QColorVector *buffer, const qsizetype len, +static void storeOpaque(T *dst, const QColorVector *buffer, const qsizetype len, const QColorTransformPrivate *d_ptr) { - Q_UNUSED(src); - const __m128 v4080 = _mm_set1_ps(4080.f); + const __m128 vTrcRes = _mm_set1_ps(float(QColorTrcLut::Resolution)); constexpr bool isARGB = isArgb<T>(); for (qsizetype i = 0; i < len; ++i) { __m128 vf = _mm_loadu_ps(&buffer[i].x); - __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, v4080)); + __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, vTrcRes)); const int ridx = _mm_extract_epi16(v, 0); const int gidx = _mm_extract_epi16(v, 2); const int bidx = _mm_extract_epi16(v, 4); @@ -854,12 +976,10 @@ static void storeOpaque(T *dst, const T *src, const QColorVector *buffer, const } template<> -void storeOpaque<QRgbaFloat32>(QRgbaFloat32 *dst, const QRgbaFloat32 *src, - const QColorVector *buffer, const qsizetype len, - const QColorTransformPrivate *d_ptr) +void storeOpaque(QRgbaFloat32 *dst, const QColorVector *buffer, const qsizetype len, + const QColorTransformPrivate *d_ptr) { - Q_UNUSED(src); - const __m128 v4080 = _mm_set1_ps(4080.f); + const __m128 vTrcRes = _mm_set1_ps(float(QColorTrcLut::Resolution)); const __m128 vZero = _mm_set1_ps(0.0f); const __m128 vOne = _mm_set1_ps(1.0f); const __m128 viFF00 = _mm_set1_ps(1.0f / (255 * 256)); @@ -869,7 +989,7 @@ void storeOpaque<QRgbaFloat32>(QRgbaFloat32 *dst, const QRgbaFloat32 *src, const __m128 over = _mm_cmpgt_ps(vf, vOne); if (_mm_movemask_ps(_mm_or_ps(under, over)) == 0) { // Within gamut - __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, v4080)); + __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, vTrcRes)); const int ridx = _mm_extract_epi16(v, 0); const int gidx = _mm_extract_epi16(v, 2); const int bidx = _mm_extract_epi16(v, 4); @@ -902,16 +1022,17 @@ inline void storeP<QRgba64>(QRgba64 &p, const uint16x4_t &v) vst1_u16((uint16_t *)&p, v); } -template<typename T> -static void storePremultiplied(T *dst, const T *src, const QColorVector *buffer, const qsizetype len, +template<typename D, typename S, + typename = std::enable_if_t<!std::is_same_v<D, QRgbaFloat32>, void>> +static void storePremultiplied(D *dst, const S *src, const QColorVector *buffer, const qsizetype len, const QColorTransformPrivate *d_ptr) { const float iFF00 = 1.0f / (255 * 256); - constexpr bool isARGB = isArgb<T>(); + constexpr bool isARGB = isArgb<D>(); for (qsizetype i = 0; i < len; ++i) { - const int a = getAlpha<T>(src[i]); + const int a = getAlpha<S>(src[i]); float32x4_t vf = vld1q_f32(&buffer[i].x); - uint32x4_t v = vcvtq_u32_f32(vaddq_f32(vmulq_n_f32(vf, 4080.f), vdupq_n_f32(0.5f))); + uint32x4_t v = vcvtq_u32_f32(vaddq_f32(vmulq_n_f32(vf, float(QColorTrcLut::Resolution)), vdupq_n_f32(0.5f))); const int ridx = vgetq_lane_u32(v, 0); const int gidx = vgetq_lane_u32(v, 1); const int bidx = vgetq_lane_u32(v, 2); @@ -924,7 +1045,7 @@ static void storePremultiplied(T *dst, const T *src, const QColorVector *buffer, v = vcvtq_u32_f32(vf); uint16x4_t v16 = vmovn_u32(v); v16 = vset_lane_u16(a, v16, 3); - storeP<T>(dst[i], v16); + storeP<D>(dst[i], v16); } } @@ -946,34 +1067,34 @@ inline void storePU<QRgba64>(QRgba64 &p, uint16x4_t &v, int a) vst1_u16((uint16_t *)&p, v); } -template<typename T> -static void storeUnpremultiplied(T *dst, const T *src, const QColorVector *buffer, const qsizetype len, +template<typename D, typename S, + typename = std::enable_if_t<!std::is_same_v<D, QRgbaFloat32>, void>> +static void storeUnpremultiplied(D *dst, const S *src, const QColorVector *buffer, const qsizetype len, const QColorTransformPrivate *d_ptr) { - constexpr bool isARGB = isArgb<T>(); + constexpr bool isARGB = isArgb<D>(); for (qsizetype i = 0; i < len; ++i) { - const int a = getAlpha<T>(src[i]); + const int a = getAlpha<S>(src[i]); float32x4_t vf = vld1q_f32(&buffer[i].x); - uint16x4_t v = vmovn_u32(vcvtq_u32_f32(vaddq_f32(vmulq_n_f32(vf, 4080.f), vdupq_n_f32(0.5f)))); + uint16x4_t v = vmovn_u32(vcvtq_u32_f32(vaddq_f32(vmulq_n_f32(vf, float(QColorTrcLut::Resolution)), vdupq_n_f32(0.5f)))); const int ridx = vget_lane_u16(v, 0); const int gidx = vget_lane_u16(v, 1); const int bidx = vget_lane_u16(v, 2); v = vset_lane_u16(d_ptr->colorSpaceOut->lut[0]->m_fromLinear[ridx], v, isARGB ? 2 : 0); v = vset_lane_u16(d_ptr->colorSpaceOut->lut[1]->m_fromLinear[gidx], v, 1); v = vset_lane_u16(d_ptr->colorSpaceOut->lut[2]->m_fromLinear[bidx], v, isARGB ? 0 : 2); - storePU<T>(dst[i], v, a); + storePU<D>(dst[i], v, a); } } template<typename T> -static void storeOpaque(T *dst, const T *src, const QColorVector *buffer, const qsizetype len, +static void storeOpaque(T *dst, const QColorVector *buffer, const qsizetype len, const QColorTransformPrivate *d_ptr) { - Q_UNUSED(src); constexpr bool isARGB = isArgb<T>(); for (qsizetype i = 0; i < len; ++i) { float32x4_t vf = vld1q_f32(&buffer[i].x); - uint16x4_t v = vmovn_u32(vcvtq_u32_f32(vaddq_f32(vmulq_n_f32(vf, 4080.f), vdupq_n_f32(0.5f)))); + uint16x4_t v = vmovn_u32(vcvtq_u32_f32(vaddq_f32(vmulq_n_f32(vf, float(QColorTrcLut::Resolution)), vdupq_n_f32(0.5f)))); const int ridx = vget_lane_u16(v, 0); const int gidx = vget_lane_u16(v, 1); const int bidx = vget_lane_u16(v, 2); @@ -990,9 +1111,9 @@ static void storePremultiplied(QRgb *dst, const QRgb *src, const QColorVector *b for (qsizetype i = 0; i < len; ++i) { const int a = qAlpha(src[i]); const float fa = a / (255.0f * 256.0f); - const float r = d_ptr->colorSpaceOut->lut[0]->m_fromLinear[int(buffer[i].x * 4080.0f + 0.5f)]; - const float g = d_ptr->colorSpaceOut->lut[1]->m_fromLinear[int(buffer[i].y * 4080.0f + 0.5f)]; - const float b = d_ptr->colorSpaceOut->lut[2]->m_fromLinear[int(buffer[i].z * 4080.0f + 0.5f)]; + const float r = d_ptr->colorSpaceOut->lut[0]->m_fromLinear[int(buffer[i].x * float(QColorTrcLut::Resolution) + 0.5f)]; + const float g = d_ptr->colorSpaceOut->lut[1]->m_fromLinear[int(buffer[i].y * float(QColorTrcLut::Resolution) + 0.5f)]; + const float b = d_ptr->colorSpaceOut->lut[2]->m_fromLinear[int(buffer[i].z * float(QColorTrcLut::Resolution) + 0.5f)]; dst[i] = qRgba(r * fa + 0.5f, g * fa + 0.5f, b * fa + 0.5f, a); } } @@ -1008,10 +1129,9 @@ static void storeUnpremultiplied(QRgb *dst, const QRgb *src, const QColorVector } } -static void storeOpaque(QRgb *dst, const QRgb *src, const QColorVector *buffer, const qsizetype len, +static void storeOpaque(QRgb *dst, const QColorVector *buffer, const qsizetype len, const QColorTransformPrivate *d_ptr) { - Q_UNUSED(src); for (qsizetype i = 0; i < len; ++i) { const int r = d_ptr->colorSpaceOut->lut[0]->u8FromLinearF32(buffer[i].x); const int g = d_ptr->colorSpaceOut->lut[1]->u8FromLinearF32(buffer[i].y); @@ -1020,34 +1140,36 @@ static void storeOpaque(QRgb *dst, const QRgb *src, const QColorVector *buffer, } } -static void storePremultiplied(QRgba64 *dst, const QRgba64 *src, const QColorVector *buffer, const qsizetype len, +template<typename S> +static void storePremultiplied(QRgba64 *dst, const S *src, const QColorVector *buffer, const qsizetype len, const QColorTransformPrivate *d_ptr) { for (qsizetype i = 0; i < len; ++i) { - const int a = src[i].alpha(); + const int a = getAlphaF(src[i]) * 65535.f; const float fa = a / (255.0f * 256.0f); - const float r = d_ptr->colorSpaceOut->lut[0]->m_fromLinear[int(buffer[i].x * 4080.0f + 0.5f)]; - const float g = d_ptr->colorSpaceOut->lut[1]->m_fromLinear[int(buffer[i].y * 4080.0f + 0.5f)]; - const float b = d_ptr->colorSpaceOut->lut[2]->m_fromLinear[int(buffer[i].z * 4080.0f + 0.5f)]; + const float r = d_ptr->colorSpaceOut->lut[0]->m_fromLinear[int(buffer[i].x * float(QColorTrcLut::Resolution) + 0.5f)]; + const float g = d_ptr->colorSpaceOut->lut[1]->m_fromLinear[int(buffer[i].y * float(QColorTrcLut::Resolution) + 0.5f)]; + const float b = d_ptr->colorSpaceOut->lut[2]->m_fromLinear[int(buffer[i].z * float(QColorTrcLut::Resolution) + 0.5f)]; dst[i] = qRgba64(r * fa + 0.5f, g * fa + 0.5f, b * fa + 0.5f, a); } } -static void storeUnpremultiplied(QRgba64 *dst, const QRgba64 *src, const QColorVector *buffer, const qsizetype len, +template<typename S> +static void storeUnpremultiplied(QRgba64 *dst, const S *src, const QColorVector *buffer, const qsizetype len, const QColorTransformPrivate *d_ptr) { for (qsizetype i = 0; i < len; ++i) { + const int a = getAlphaF(src[i]) * 65535.f; const int r = d_ptr->colorSpaceOut->lut[0]->u16FromLinearF32(buffer[i].x); const int g = d_ptr->colorSpaceOut->lut[1]->u16FromLinearF32(buffer[i].y); const int b = d_ptr->colorSpaceOut->lut[2]->u16FromLinearF32(buffer[i].z); - dst[i] = qRgba64(r, g, b, src[i].alpha()); + dst[i] = qRgba64(r, g, b, a); } } -static void storeOpaque(QRgba64 *dst, const QRgba64 *src, const QColorVector *buffer, const qsizetype len, +static void storeOpaque(QRgba64 *dst, const QColorVector *buffer, const qsizetype len, const QColorTransformPrivate *d_ptr) { - Q_UNUSED(src); for (qsizetype i = 0; i < len; ++i) { const int r = d_ptr->colorSpaceOut->lut[0]->u16FromLinearF32(buffer[i].x); const int g = d_ptr->colorSpaceOut->lut[1]->u16FromLinearF32(buffer[i].y); @@ -1057,11 +1179,12 @@ static void storeOpaque(QRgba64 *dst, const QRgba64 *src, const QColorVector *bu } #endif #if !defined(__SSE2__) -static void storePremultiplied(QRgbaFloat32 *dst, const QRgbaFloat32 *src, const QColorVector *buffer, +template<typename S> +static void storePremultiplied(QRgbaFloat32 *dst, const S *src, const QColorVector *buffer, const qsizetype len, const QColorTransformPrivate *d_ptr) { for (qsizetype i = 0; i < len; ++i) { - const float a = src[i].a; + const float a = getAlphaF(src[i]); dst[i].r = d_ptr->colorSpaceOut->trc[0].applyInverseExtended(buffer[i].x) * a; dst[i].g = d_ptr->colorSpaceOut->trc[1].applyInverseExtended(buffer[i].y) * a; dst[i].b = d_ptr->colorSpaceOut->trc[2].applyInverseExtended(buffer[i].z) * a; @@ -1069,11 +1192,12 @@ static void storePremultiplied(QRgbaFloat32 *dst, const QRgbaFloat32 *src, const } } -static void storeUnpremultiplied(QRgbaFloat32 *dst, const QRgbaFloat32 *src, const QColorVector *buffer, +template<typename S> +static void storeUnpremultiplied(QRgbaFloat32 *dst, const S *src, const QColorVector *buffer, const qsizetype len, const QColorTransformPrivate *d_ptr) { for (qsizetype i = 0; i < len; ++i) { - const float a = src[i].a; + const float a = getAlphaF(src[i]); dst[i].r = d_ptr->colorSpaceOut->trc[0].applyInverseExtended(buffer[i].x); dst[i].g = d_ptr->colorSpaceOut->trc[1].applyInverseExtended(buffer[i].y); dst[i].b = d_ptr->colorSpaceOut->trc[2].applyInverseExtended(buffer[i].z); @@ -1081,10 +1205,9 @@ static void storeUnpremultiplied(QRgbaFloat32 *dst, const QRgbaFloat32 *src, con } } -static void storeOpaque(QRgbaFloat32 *dst, const QRgbaFloat32 *src, const QColorVector *buffer, const qsizetype len, +static void storeOpaque(QRgbaFloat32 *dst, const QColorVector *buffer, const qsizetype len, const QColorTransformPrivate *d_ptr) { - Q_UNUSED(src); for (qsizetype i = 0; i < len; ++i) { dst[i].r = d_ptr->colorSpaceOut->trc[0].applyInverseExtended(buffer[i].x); dst[i].g = d_ptr->colorSpaceOut->trc[1].applyInverseExtended(buffer[i].y); @@ -1093,20 +1216,35 @@ static void storeOpaque(QRgbaFloat32 *dst, const QRgbaFloat32 *src, const QColor } } #endif -static void storeGray(quint8 *dst, const QRgb *src, const QColorVector *buffer, const qsizetype len, + +static void loadGray(QColorVector *buffer, const quint8 *src, const qsizetype len, const QColorTransformPrivate *d_ptr) +{ + for (qsizetype i = 0; i < len; ++i) { + const float y = d_ptr->colorSpaceIn->lut[0]->u8ToLinearF32(src[i]); + buffer[i] = d_ptr->colorSpaceIn->whitePoint * y; + } +} + +static void loadGray(QColorVector *buffer, const quint16 *src, const qsizetype len, const QColorTransformPrivate *d_ptr) +{ + for (qsizetype i = 0; i < len; ++i) { + const float y = d_ptr->colorSpaceIn->lut[0]->u16ToLinearF32(src[i]); + buffer[i] = d_ptr->colorSpaceIn->whitePoint * y; + } +} + +static void storeOpaque(quint8 *dst, const QColorVector *buffer, const qsizetype len, const QColorTransformPrivate *d_ptr) { - Q_UNUSED(src); for (qsizetype i = 0; i < len; ++i) - dst[i] = d_ptr->colorSpaceOut->lut[1]->u8FromLinearF32(buffer[i].y); + dst[i] = d_ptr->colorSpaceOut->lut[0]->u8FromLinearF32(buffer[i].y); } -static void storeGray(quint16 *dst, const QRgba64 *src, const QColorVector *buffer, const qsizetype len, +static void storeOpaque(quint16 *dst, const QColorVector *buffer, const qsizetype len, const QColorTransformPrivate *d_ptr) { - Q_UNUSED(src); for (qsizetype i = 0; i < len; ++i) - dst[i] = d_ptr->colorSpaceOut->lut[1]->u16FromLinearF32(buffer[i].y); + dst[i] = d_ptr->colorSpaceOut->lut[0]->u16FromLinearF32(buffer[i].y); } static constexpr qsizetype WorkBlockSize = 256; @@ -1120,53 +1258,493 @@ private: alignas(T) char data[sizeof(T) * Count]; }; +void loadUnpremultipliedLUT(QColorVector *buffer, const QRgb *src, const qsizetype len) +{ + const float f = 1.0f / 255.f; + for (qsizetype i = 0; i < len; ++i) { + const uint p = src[i]; + buffer[i].x = qRed(p) * f; + buffer[i].y = qGreen(p) * f; + buffer[i].z = qBlue(p) * f; + } +} + +void loadUnpremultipliedLUT(QColorVector *buffer, const QCmyk32 *src, const qsizetype len) +{ + const float f = 1.0f / 255.f; + for (qsizetype i = 0; i < len; ++i) { + const QCmyk32 p = src[i]; + buffer[i].x = (p.cyan() * f); + buffer[i].y = (p.magenta() * f); + buffer[i].z = (p.yellow() * f); + buffer[i].w = (p.black() * f); + } +} + +void loadUnpremultipliedLUT(QColorVector *buffer, const QRgba64 *src, const qsizetype len) +{ + const float f = 1.0f / 65535.f; + for (qsizetype i = 0; i < len; ++i) { + buffer[i].x = src[i].red() * f; + buffer[i].y = src[i].green() * f; + buffer[i].z = src[i].blue() * f; + } +} + +void loadUnpremultipliedLUT(QColorVector *buffer, const QRgbaFloat32 *src, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) { + buffer[i].x = src[i].r; + buffer[i].y = src[i].g; + buffer[i].z = src[i].b; + } +} + +void loadPremultipliedLUT(QColorVector *buffer, const QRgb *src, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) { + const uint p = src[i]; + const float f = 1.0f / qAlpha(p); + buffer[i].x = (qRed(p) * f); + buffer[i].y = (qGreen(p) * f); + buffer[i].z = (qBlue(p) * f); + } +} + +void loadPremultipliedLUT(QColorVector *, const QCmyk32 *, const qsizetype) +{ + Q_UNREACHABLE(); +} + +void loadPremultipliedLUT(QColorVector *buffer, const QRgba64 *src, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) { + const float f = 1.0f / src[i].alpha(); + buffer[i].x = (src[i].red() * f); + buffer[i].y = (src[i].green() * f); + buffer[i].z = (src[i].blue() * f); + } +} + +void loadPremultipliedLUT(QColorVector *buffer, const QRgbaFloat32 *src, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) { + const float f = 1.0f / src[i].a; + buffer[i].x = src[i].r * f; + buffer[i].y = src[i].g * f; + buffer[i].z = src[i].b * f; + } +} template<typename T> -void QColorTransformPrivate::apply(T *dst, const T *src, qsizetype count, TransformFlags flags) const +static void storeUnpremultipliedLUT(QRgb *dst, const T *, const QColorVector *buffer, const qsizetype len) { - if (!colorMatrix.isValid()) + for (qsizetype i = 0; i < len; ++i) { + const int r = buffer[i].x * 255.f; + const int g = buffer[i].y * 255.f; + const int b = buffer[i].z * 255.f; + dst[i] = 0xff000000 | (r << 16) | (g << 8) | (b << 0); + } +} + +template<> +void storeUnpremultipliedLUT(QRgb *dst, const QRgb *src, const QColorVector *buffer, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) { + const int r = buffer[i].x * 255.f; + const int g = buffer[i].y * 255.f; + const int b = buffer[i].z * 255.f; + dst[i] = (src[i] & 0xff000000) | (r << 16) | (g << 8) | (b << 0); + } +} + + +template<typename T> +void storeUnpremultipliedLUT(QCmyk32 *dst, const T *, const QColorVector *buffer, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) { + const int c = buffer[i].x * 255.f; + const int m = buffer[i].y * 255.f; + const int y = buffer[i].z * 255.f; + const int k = buffer[i].w * 255.f; + dst[i] = QCmyk32(c, m, y, k); + } +} + +template<typename T> +static void storeUnpremultipliedLUT(QRgba64 *dst, const T *, + const QColorVector *buffer, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) { + const int r = buffer[i].x * 65535.f; + const int g = buffer[i].y * 65535.f; + const int b = buffer[i].z * 65535.f; + dst[i] = qRgba64(r, g, b, 65535); + } +} + +template<> +void storeUnpremultipliedLUT(QRgba64 *dst, const QRgb *src, + const QColorVector *buffer, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) { + const int a = qAlpha(src[i]) * 257; + const int r = buffer[i].x * 65535.f; + const int g = buffer[i].y * 65535.f; + const int b = buffer[i].z * 65535.f; + dst[i] = qRgba64(r, g, b, a); + } +} + +template<> +void storeUnpremultipliedLUT(QRgba64 *dst, const QRgba64 *src, + const QColorVector *buffer, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) { + const int r = buffer[i].x * 65535.f; + const int g = buffer[i].y * 65535.f; + const int b = buffer[i].z * 65535.f; + dst[i] = qRgba64(r, g, b, src[i].alpha()); + } +} + +template<typename T> +static void storeUnpremultipliedLUT(QRgbaFloat32 *dst, const T *src, + const QColorVector *buffer, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) { + const float r = buffer[i].x; + const float g = buffer[i].y; + const float b = buffer[i].z; + dst[i] = QRgbaFloat32{r, g, b, getAlphaF(src[i])}; + } +} + +template<typename T> +static void storePremultipliedLUT(QRgb *, const T *, const QColorVector *, const qsizetype); + +template<> +void storePremultipliedLUT(QRgb *dst, const QRgb *src, const QColorVector *buffer, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) { + const int a = qAlpha(src[i]); + const int r = buffer[i].x * a; + const int g = buffer[i].y * a; + const int b = buffer[i].z * a; + dst[i] = (src[i] & 0xff000000) | (r << 16) | (g << 8) | (b << 0); + } +} + +template<> +void storePremultipliedLUT(QRgb *dst, const QCmyk32 *, const QColorVector *buffer, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) { + const int r = buffer[i].x * 255.f; + const int g = buffer[i].y * 255.f; + const int b = buffer[i].z * 255.f; + dst[i] = 0xff000000 | (r << 16) | (g << 8) | (b << 0); + } +} + + +template<typename T> +static void storePremultipliedLUT(QCmyk32 *dst, const T *src, const QColorVector *buffer, const qsizetype len) +{ + storeUnpremultipliedLUT(dst, src, buffer, len); +} + +template<typename T> +static void storePremultipliedLUT(QRgba64 *, const T *, const QColorVector *, const qsizetype); + +template<> +void storePremultipliedLUT(QRgba64 *dst, const QRgb *src, const QColorVector *buffer, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) { + const int a = qAlpha(src[i]) * 257; + const int r = buffer[i].x * a; + const int g = buffer[i].y * a; + const int b = buffer[i].z * a; + dst[i] = qRgba64(r, g, b, a); + } +} + +template<> +void storePremultipliedLUT(QRgba64 *dst, const QCmyk32 *, const QColorVector *buffer, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) { + const int r = buffer[i].x * 65535.f; + const int g = buffer[i].y * 65535.f; + const int b = buffer[i].z * 65535.f; + dst[i] = qRgba64(r, g, b, 65535); + } +} + +template<> +void storePremultipliedLUT(QRgba64 *dst, const QRgba64 *src, const QColorVector *buffer, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) { + const int a = src[i].alpha(); + const int r = buffer[i].x * a; + const int g = buffer[i].y * a; + const int b = buffer[i].z * a; + dst[i] = qRgba64(r, g, b, a); + } +} + +template<typename T> +static void storePremultipliedLUT(QRgbaFloat32 *dst, const T *src, const QColorVector *buffer, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) { + const float a = getAlphaF(src[i]); + const float r = buffer[i].x * a; + const float g = buffer[i].y * a; + const float b = buffer[i].z * a; + dst[i] = QRgbaFloat32{r, g, b, a}; + } +} + +static void visitElement(const QColorSpacePrivate::TransferElement &element, QColorVector *buffer, const qsizetype len) +{ + const bool doW = element.trc[3].isValid(); + for (qsizetype i = 0; i < len; ++i) { + buffer[i].x = element.trc[0].apply(buffer[i].x); + buffer[i].y = element.trc[1].apply(buffer[i].y); + buffer[i].z = element.trc[2].apply(buffer[i].z); + if (doW) + buffer[i].w = element.trc[3].apply(buffer[i].w); + } +} + +static void visitElement(const QColorMatrix &element, QColorVector *buffer, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) + buffer[i] = element.map(buffer[i]); +} + +static void visitElement(const QColorVector &offset, QColorVector *buffer, const qsizetype len) +{ + for (qsizetype i = 0; i < len; ++i) + buffer[i] += offset; +} + +static void visitElement(const QColorCLUT &element, QColorVector *buffer, const qsizetype len) +{ + if (element.isEmpty()) return; + for (qsizetype i = 0; i < len; ++i) + buffer[i] = element.apply(buffer[i]); +} - updateLutsIn(); - updateLutsOut(); +/*! + \internal +*/ +QColorVector QColorTransformPrivate::map(QColorVector c) const +{ + if (colorSpaceIn->isThreeComponentMatrix()) { + if (colorSpaceIn->lut.generated.loadAcquire()) { + c.x = colorSpaceIn->lut[0]->toLinear(c.x); + c.y = colorSpaceIn->lut[1]->toLinear(c.y); + c.z = colorSpaceIn->lut[2]->toLinear(c.z); + } else { + c.x = colorSpaceIn->trc[0].apply(c.x); + c.y = colorSpaceIn->trc[1].apply(c.y); + c.z = colorSpaceIn->trc[2].apply(c.z); + } + c = colorMatrix.map(c); + } else { + // Do element based conversion + for (auto &&element : colorSpaceIn->mAB) + std::visit([&c](auto &&elm) { visitElement(elm, &c, 1); }, element); + } + c.x = std::clamp(c.x, 0.0f, 1.0f); + c.y = std::clamp(c.y, 0.0f, 1.0f); + c.z = std::clamp(c.z, 0.0f, 1.0f); + + // Match Profile Connection Spaces (PCS): + if (colorSpaceOut->isPcsLab && !colorSpaceIn->isPcsLab) + c = c.xyzToLab(); + else if (colorSpaceIn->isPcsLab && !colorSpaceOut->isPcsLab) + c = c.labToXyz(); + + if (colorSpaceOut->isThreeComponentMatrix()) { + if (!colorSpaceIn->isThreeComponentMatrix()) { + c = colorMatrix.map(c); + c.x = std::clamp(c.x, 0.0f, 1.0f); + c.y = std::clamp(c.y, 0.0f, 1.0f); + c.z = std::clamp(c.z, 0.0f, 1.0f); + } + if (colorSpaceOut->lut.generated.loadAcquire()) { + c.x = colorSpaceOut->lut[0]->fromLinear(c.x); + c.y = colorSpaceOut->lut[1]->fromLinear(c.y); + c.z = colorSpaceOut->lut[2]->fromLinear(c.z); + } else { + c.x = colorSpaceOut->trc[0].applyInverse(c.x); + c.y = colorSpaceOut->trc[1].applyInverse(c.y); + c.z = colorSpaceOut->trc[2].applyInverse(c.z); + } + } else { + // Do element based conversion + for (auto &&element : colorSpaceOut->mBA) + std::visit([&c](auto &&elm) { visitElement(elm, &c, 1); }, element); + c.x = std::clamp(c.x, 0.0f, 1.0f); + c.y = std::clamp(c.y, 0.0f, 1.0f); + c.z = std::clamp(c.z, 0.0f, 1.0f); + } + return c; +} - bool doApplyMatrix = (colorMatrix != QColorMatrix::identity()); - constexpr bool DoClip = !std::is_same_v<T, QRgbaFloat16> && !std::is_same_v<T, QRgbaFloat32>; +/*! + \internal +*/ +QColorVector QColorTransformPrivate::mapExtended(QColorVector c) const +{ + if (colorSpaceIn->isThreeComponentMatrix()) { + c.x = colorSpaceIn->trc[0].applyExtended(c.x); + c.y = colorSpaceIn->trc[1].applyExtended(c.y); + c.z = colorSpaceIn->trc[2].applyExtended(c.z); + c = colorMatrix.map(c); + } else { + // Do element based conversion + for (auto &&element : colorSpaceIn->mAB) + std::visit([&c](auto &&elm) { visitElement(elm, &c, 1); }, element); + } - QUninitialized<QColorVector, WorkBlockSize> buffer; + // Match Profile Connection Spaces (PCS): + if (colorSpaceOut->isPcsLab && !colorSpaceIn->isPcsLab) + c = c.xyzToLab(); + else if (colorSpaceIn->isPcsLab && !colorSpaceOut->isPcsLab) + c = c.labToXyz(); + + if (colorSpaceOut->isThreeComponentMatrix()) { + if (!colorSpaceIn->isThreeComponentMatrix()) + c = colorMatrix.map(c); + c.x = colorSpaceOut->trc[0].applyInverseExtended(c.x); + c.y = colorSpaceOut->trc[1].applyInverseExtended(c.y); + c.z = colorSpaceOut->trc[2].applyInverseExtended(c.z); + } else { + // Do element based conversion + for (auto &&element : colorSpaceOut->mBA) + std::visit([&c](auto &&elm) { visitElement(elm, &c, 1); }, element); + } + return c; +} + +template<typename S> +void QColorTransformPrivate::applyConvertIn(const S *src, QColorVector *buffer, qsizetype len, TransformFlags flags) const +{ + // Avoid compiling this part for S=QCmyk32: + if constexpr (!std::is_same_v<S, QCmyk32>) { + if (colorSpaceIn->isThreeComponentMatrix()) { + if (flags & InputPremultiplied) + loadPremultiplied(buffer, src, len, this); + else + loadUnpremultiplied(buffer, src, len, this); + + if (!colorSpaceOut->isThreeComponentMatrix()) + applyMatrix<DoClamp>(buffer, len, colorMatrix); // colorMatrix should have the first half only. + return; + } + } + Q_ASSERT(!colorSpaceIn->isThreeComponentMatrix()); + + if (flags & InputPremultiplied) + loadPremultipliedLUT(buffer, src, len); + else + loadUnpremultipliedLUT(buffer, src, len); + + if constexpr (std::is_same_v<S, QRgbaFloat16> || std::is_same_v<S, QRgbaFloat32>) + clampIfNeeded<DoClamp>(buffer, len); + + // Do element based conversion + for (auto &&element : colorSpaceIn->mAB) + std::visit([&buffer, len](auto &&elm) { visitElement(elm, buffer, len); }, element); +} + +template<typename D, typename S> +void QColorTransformPrivate::applyConvertOut(D *dst, const S *src, QColorVector *buffer, qsizetype len, TransformFlags flags) const +{ + constexpr ApplyMatrixForm doClamp = (std::is_same_v<D, QRgbaFloat16> || std::is_same_v<D, QRgbaFloat32>) ? DoNotClamp : DoClamp; + // Avoid compiling this part for D=QCmyk32: + if constexpr (!std::is_same_v<D, QCmyk32>) { + if (colorSpaceOut->isThreeComponentMatrix()) { + applyMatrix<doClamp>(buffer, len, colorMatrix); // colorMatrix should have the latter half only. + + if constexpr (std::is_same_v<S, QCmyk32>) { + storeOpaque(dst, buffer, len, this); + } else { + if (flags & InputOpaque) + storeOpaque(dst, buffer, len, this); + else if (flags & OutputPremultiplied) + storePremultiplied(dst, src, buffer, len, this); + else + storeUnpremultiplied(dst, src, buffer, len, this); + } + return; + } + } + Q_ASSERT(!colorSpaceOut->isThreeComponentMatrix()); + + // Do element based conversion + for (auto &&element : colorSpaceOut->mBA) + std::visit([&buffer, len](auto &&elm) { visitElement(elm, buffer, len); }, element); + + clampIfNeeded<doClamp>(buffer, len); + + if (flags & OutputPremultiplied) + storePremultipliedLUT(dst, src, buffer, len); + else + storeUnpremultipliedLUT(dst, src, buffer, len); +} + +template<typename D, typename S> +void QColorTransformPrivate::applyElementListTransform(D *dst, const S *src, qsizetype count, TransformFlags flags) const +{ + Q_ASSERT(!colorSpaceIn->isThreeComponentMatrix() || !colorSpaceOut->isThreeComponentMatrix()); + if (!colorMatrix.isValid()) + return; + + if (colorSpaceIn->isThreeComponentMatrix()) + updateLutsIn(); + if (colorSpaceOut->isThreeComponentMatrix()) + updateLutsOut(); + + QUninitialized<QColorVector, WorkBlockSize> buffer; qsizetype i = 0; while (i < count) { const qsizetype len = qMin(count - i, WorkBlockSize); - if (flags & InputPremultiplied) - loadPremultiplied(buffer, src + i, len, this); - else - loadUnpremultiplied(buffer, src + i, len, this); - if (doApplyMatrix) - applyMatrix<DoClip>(buffer, len, colorMatrix); + applyConvertIn(src + i, buffer, len, flags); - if (flags & InputOpaque) - storeOpaque(dst + i, src + i, buffer, len, this); - else if (flags & OutputPremultiplied) - storePremultiplied(dst + i, src + i, buffer, len, this); - else - storeUnpremultiplied(dst + i, src + i, buffer, len, this); + // Match Profile Connection Spaces (PCS): + if (colorSpaceOut->isPcsLab && !colorSpaceIn->isPcsLab) { + for (qsizetype j = 0; j < len; ++j) + buffer[j] = buffer[j].xyzToLab(); + } else if (colorSpaceIn->isPcsLab && !colorSpaceOut->isPcsLab) { + for (qsizetype j = 0; j < len; ++j) + buffer[j] = buffer[j].labToXyz(); + } + + applyConvertOut(dst + i, src + i, buffer, len, flags); i += len; } } template<typename D, typename S> -void QColorTransformPrivate::applyReturnGray(D *dst, const S *src, qsizetype count, TransformFlags flags) const +void QColorTransformPrivate::applyThreeComponentMatrix(D *dst, const S *src, qsizetype count, TransformFlags flags) const { + Q_ASSERT(colorSpaceIn->isThreeComponentMatrix() && colorSpaceOut->isThreeComponentMatrix()); + if (!colorMatrix.isValid()) return; updateLutsIn(); updateLutsOut(); - QUninitialized<QColorVector, WorkBlockSize> buffer; + bool doApplyMatrix = !colorMatrix.isIdentity(); + constexpr ApplyMatrixForm doClamp = (std::is_same_v<D, QRgbaFloat16> || std::is_same_v<D, QRgbaFloat32>) ? DoNotClamp : DoClamp; + QUninitialized<QColorVector, WorkBlockSize> buffer; qsizetype i = 0; while (i < count) { const qsizetype len = qMin(count - i, WorkBlockSize); @@ -1175,9 +1753,17 @@ void QColorTransformPrivate::applyReturnGray(D *dst, const S *src, qsizetype cou else loadUnpremultiplied(buffer, src + i, len, this); - applyMatrix(buffer, len, colorMatrix); + if (doApplyMatrix) + applyMatrix<doClamp>(buffer, len, colorMatrix); + else + clampIfNeeded<doClamp>(buffer, len); - storeGray(dst + i, src + i, buffer, len, this); + if (flags & InputOpaque) + storeOpaque(dst + i, buffer, len, this); + else if (flags & OutputPremultiplied) + storePremultiplied(dst + i, src + i, buffer, len, this); + else + storeUnpremultiplied(dst + i, src + i, buffer, len, this); i += len; } @@ -1185,100 +1771,244 @@ void QColorTransformPrivate::applyReturnGray(D *dst, const S *src, qsizetype cou /*! \internal - \enum QColorTransformPrivate::TransformFlag + Applies the color transformation on \a count S pixels starting from + \a src and stores the result in \a dst as D pixels . - Defines how the transform is to be applied. + Assumes unpremultiplied data by default. Set \a flags to change defaults. - \value Unpremultiplied The input and output should both be unpremultiplied. - \value InputOpaque The input is guaranteed to be opaque. - \value InputPremultiplied The input is premultiplied. - \value OutputPremultiplied The output should be premultiplied. - \value Premultiplied Both input and output should both be premultiplied. + \sa prepare() */ +template<typename D, typename S> +void QColorTransformPrivate::apply(D *dst, const S *src, qsizetype count, TransformFlags flags) const +{ + if constexpr (!std::is_same_v<D, QCmyk32> && !std::is_same_v<S, QCmyk32>) { + if (isThreeComponentMatrix()) + return applyThreeComponentMatrix<D, S>(dst, src, count, flags); + } + applyElementListTransform<D, S>(dst, src, count, flags); +} /*! \internal - Prepares a color transformation for fast application. You do not need to - call this explicitly as it will be called implicitly on the first transforms, but - if you want predictable performance on the first transforms, you can perform it - in advance. + Is to be called on a color-transform to XYZ, returns only luminance values. - \sa QColorTransform::map(), apply() -*/ -void QColorTransformPrivate::prepare() + */ +template<typename D, typename S> +void QColorTransformPrivate::applyReturnGray(D *dst, const S *src, qsizetype count, TransformFlags flags) const { - updateLutsIn(); + Q_ASSERT(colorSpaceOut->isThreeComponentMatrix()); updateLutsOut(); -} + if (!colorSpaceIn->isThreeComponentMatrix()) { + QUninitialized<QColorVector, WorkBlockSize> buffer; -/*! - \internal - Applies the color transformation on \a count QRgb pixels starting from - \a src and stores the result in \a dst. + qsizetype i = 0; + while (i < count) { + const qsizetype len = qMin(count - i, WorkBlockSize); - Thread-safe if prepare() has been called first. + applyConvertIn(src, buffer, len, flags); - Assumes unpremultiplied data by default. Set \a flags to change defaults. + // Match Profile Connection Spaces (PCS): + if (colorSpaceOut->isPcsLab && !colorSpaceIn->isPcsLab) { + for (qsizetype j = 0; j < len; ++j) + buffer[j] = buffer[j].xyzToLab(); + } else if (colorSpaceIn->isPcsLab && !colorSpaceOut->isPcsLab) { + for (qsizetype j = 0; j < len; ++j) + buffer[j] = buffer[j].labToXyz(); + } - \sa prepare() -*/ -void QColorTransformPrivate::apply(QRgb *dst, const QRgb *src, qsizetype count, TransformFlags flags) const -{ - apply<QRgb>(dst, src, count, flags); + applyMatrix<DoClamp>(buffer, len, colorMatrix); + storeOpaque(dst + i, buffer, len, this); + + i += len; + } + return; + } + if constexpr (!std::is_same_v<S, QCmyk32>) { + if (!colorMatrix.isValid()) + return; + + updateLutsIn(); + + QUninitialized<QColorVector, WorkBlockSize> buffer; + + qsizetype i = 0; + while (i < count) { + const qsizetype len = qMin(count - i, WorkBlockSize); + if (flags & InputPremultiplied) + loadPremultiplied(buffer, src + i, len, this); + else + loadUnpremultiplied(buffer, src + i, len, this); + + applyMatrix<DoClamp>(buffer, len, colorMatrix); + + storeOpaque(dst + i, buffer, len, this); + + i += len; + } + } else { + Q_UNREACHABLE(); + } } /*! \internal - Applies the color transformation on \a count QRgba64 pixels starting from - \a src and stores the result in \a dst. +*/ +template<typename D, typename S> +void QColorTransformPrivate::applyGray(D *dst, const S *src, qsizetype count, TransformFlags) const +{ + Q_ASSERT(colorSpaceIn->isThreeComponentMatrix()); + updateLutsIn(); + if constexpr (std::is_same_v<D, QRgb> || std::is_same_v<D, QRgba64> || std::is_same_v<D, QRgbaFloat32> || std::is_same_v<D, QCmyk32>) { + if (!colorSpaceOut->isThreeComponentMatrix()) { + QUninitialized<QColorVector, WorkBlockSize> buffer; - Thread-safe if prepare() has been called first. + qsizetype i = 0; + while (i < count) { + const qsizetype len = qMin(count - i, WorkBlockSize); + loadGray(buffer, src + i, len, this); - Assumes unpremultiplied data by default. Set \a flags to change defaults. + applyMatrix<DoClamp>(buffer, len, colorMatrix); - \sa prepare() -*/ -void QColorTransformPrivate::apply(QRgba64 *dst, const QRgba64 *src, qsizetype count, TransformFlags flags) const -{ - apply<QRgba64>(dst, src, count, flags); + // Match Profile Connection Spaces (PCS): + if (colorSpaceOut->isPcsLab && !colorSpaceIn->isPcsLab) { + for (qsizetype j = 0; j < len; ++j) + buffer[j] = buffer[j].xyzToLab(); + } else if (colorSpaceIn->isPcsLab && !colorSpaceOut->isPcsLab) { + for (qsizetype j = 0; j < len; ++j) + buffer[j] = buffer[j].labToXyz(); + } + + // Do element based conversion + for (auto &&element : colorSpaceOut->mBA) + std::visit([&buffer, len](auto &&elm) { visitElement(elm, buffer, len); }, element); + + clampIfNeeded<DoClamp>(buffer, len); + + storeUnpremultipliedLUT(dst, src, buffer, len); // input is always opaque + + i += len; + } + return; + } + } + Q_ASSERT(colorSpaceOut->isThreeComponentMatrix()); + if constexpr (!std::is_same_v<D, QCmyk32>) { + if (!colorMatrix.isValid()) + return; + + updateLutsOut(); + + QUninitialized<QColorVector, WorkBlockSize> buffer; + + qsizetype i = 0; + while (i < count) { + const qsizetype len = qMin(count - i, WorkBlockSize); + loadGray(buffer, src + i, len, this); + + applyMatrix<DoClamp>(buffer, len, colorMatrix); + + storeOpaque(dst + i, buffer, len, this); + i += len; + } + } else { + Q_UNREACHABLE(); + } } /*! \internal - Applies the color transformation on \a count QRgbaFloat32 pixels starting from - \a src and stores the result in \a dst. - - Thread-safe if prepare() has been called first. + \enum QColorTransformPrivate::TransformFlag - Assumes unpremultiplied data by default. Set \a flags to change defaults. + Defines how the transform should handle alpha values. - \sa prepare() + \value Unpremultiplied The input and output should both be unpremultiplied. + \value InputOpaque The input is guaranteed to be opaque. + \value InputPremultiplied The input is premultiplied. + \value OutputPremultiplied The output should be premultiplied. + \value Premultiplied Both input and output should both be premultiplied. */ -void QColorTransformPrivate::apply(QRgbaFloat32 *dst, const QRgbaFloat32 *src, qsizetype count, - TransformFlags flags) const -{ - apply<QRgbaFloat32>(dst, src, count, flags); -} /*! \internal - Is to be called on a color-transform to XYZ, returns only luminance values. + Prepares a color transformation for fast application. You do not need to + call this explicitly as it will be called implicitly on the first transforms, but + if you want predictable performance on the first transforms, you can perform it + in advance. + \sa QColorTransform::map(), apply() */ -void QColorTransformPrivate::apply(quint8 *dst, const QRgb *src, qsizetype count, TransformFlags flags) const +void QColorTransformPrivate::prepare() { - applyReturnGray<quint8, QRgb>(dst, src, count, flags); + updateLutsIn(); + updateLutsOut(); +} + +// Only allow versions increasing precision +template void QColorTransformPrivate::applyReturnGray<quint8, QRgb>(quint8 *dst, const QRgb *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::applyReturnGray<quint8, QCmyk32>(quint8 *dst, const QCmyk32 *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::applyReturnGray<quint16, QCmyk32>(quint16 *dst, const QCmyk32 *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::applyReturnGray<quint16, QRgba64>(quint16 *dst, const QRgba64 *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::applyGray<quint8, quint8>(quint8 *dst, const quint8 *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::applyGray<quint16, quint8>(quint16 *dst, const quint8 *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::applyGray<quint16, quint16>(quint16 *dst, const quint16 *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::applyGray<QRgb, quint8>(QRgb *dst, const quint8 *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::applyGray<QCmyk32, quint8>(QCmyk32 *dst, const quint8 *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::applyGray<QCmyk32, quint16>(QCmyk32 *dst, const quint16 *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::applyGray<QRgba64, quint16>(QRgba64 *dst, const quint16 *src, qsizetype count, TransformFlags flags) const; + +template void QColorTransformPrivate::apply<QRgb, QRgb>(QRgb *dst, const QRgb *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::apply<QRgb, QCmyk32>(QRgb *dst, const QCmyk32 *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::apply<QCmyk32, QRgb>(QCmyk32 *dst, const QRgb *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::apply<QCmyk32, QCmyk32>(QCmyk32 *dst, const QCmyk32 *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::apply<QCmyk32, QRgba64>(QCmyk32 *dst, const QRgba64 *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::apply<QCmyk32, QRgbaFloat32>(QCmyk32 *dst, const QRgbaFloat32 *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::apply<QRgba64, QRgb>(QRgba64 *dst, const QRgb *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::apply<QRgba64, QCmyk32>(QRgba64 *dst, const QCmyk32 *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::apply<QRgba64, QRgba64>(QRgba64 *dst, const QRgba64 *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::apply<QRgbaFloat32, QRgb>(QRgbaFloat32 *dst, const QRgb *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::apply<QRgbaFloat32, QCmyk32>(QRgbaFloat32 *dst, const QCmyk32 *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::apply<QRgbaFloat32, QRgba64>(QRgbaFloat32 *dst, const QRgba64 *src, qsizetype count, TransformFlags flags) const; +template void QColorTransformPrivate::apply<QRgbaFloat32, QRgbaFloat32>(QRgbaFloat32 *dst, const QRgbaFloat32 *src, qsizetype count, TransformFlags flags) const; + +bool QColorTransformPrivate::isThreeComponentMatrix() const +{ + if (colorSpaceIn && !colorSpaceIn->isThreeComponentMatrix()) + return false; + if (colorSpaceOut && !colorSpaceOut->isThreeComponentMatrix()) + return false; + return true; } /*! \internal - Is to be called on a color-transform to XYZ, returns only luminance values. - */ -void QColorTransformPrivate::apply(quint16 *dst, const QRgba64 *src, qsizetype count, TransformFlags flags) const -{ - applyReturnGray<quint16, QRgba64>(dst, src, count, flags); +bool QColorTransformPrivate::isIdentity() const +{ + if (colorSpaceIn == colorSpaceOut) + return true; + if (!colorMatrix.isIdentity()) + return false; + if (colorSpaceIn && colorSpaceOut) { + if (colorSpaceIn->equals(colorSpaceOut.constData())) + return true; + if (!isThreeComponentMatrix()) + return false; + if (colorSpaceIn->transferFunction != colorSpaceOut->transferFunction) + return false; + if (colorSpaceIn->transferFunction == QColorSpace::TransferFunction::Custom) { + return colorSpaceIn->trc[0] == colorSpaceOut->trc[0] + && colorSpaceIn->trc[1] == colorSpaceOut->trc[1] + && colorSpaceIn->trc[2] == colorSpaceOut->trc[2]; + } + } else { + if (!isThreeComponentMatrix()) + return false; + if (colorSpaceIn && colorSpaceIn->transferFunction != QColorSpace::TransferFunction::Linear) + return false; + if (colorSpaceOut && colorSpaceOut->transferFunction != QColorSpace::TransferFunction::Linear) + return false; + } + return true; } - QT_END_NAMESPACE diff --git a/src/gui/painting/qcolortransform.h b/src/gui/painting/qcolortransform.h index 3df5be7c8b..02f15ee89f 100644 --- a/src/gui/painting/qcolortransform.h +++ b/src/gui/painting/qcolortransform.h @@ -14,6 +14,12 @@ class QColor; class QRgba64; class QColorSpacePrivate; class QColorTransformPrivate; +class qfloat16; +template<typename T> +class QRgbaFloat; +typedef QRgbaFloat<qfloat16> QRgbaFloat16; +typedef QRgbaFloat<float> QRgbaFloat32; + QT_DECLARE_QESDP_SPECIALIZATION_DTOR_WITH_EXPORT(QColorTransformPrivate, Q_GUI_EXPORT) class QColorTransform @@ -31,16 +37,23 @@ public: QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_MOVE_AND_SWAP(QColorTransform) void swap(QColorTransform &other) noexcept { d.swap(other.d); } + Q_GUI_EXPORT bool isIdentity() const noexcept; Q_GUI_EXPORT QRgb map(QRgb argb) const; Q_GUI_EXPORT QRgba64 map(QRgba64 rgba64) const; + Q_GUI_EXPORT QRgbaFloat16 map(QRgbaFloat16 rgbafp16) const; + Q_GUI_EXPORT QRgbaFloat32 map(QRgbaFloat32 rgbafp32) const; Q_GUI_EXPORT QColor map(const QColor &color) const; + friend bool operator==(const QColorTransform &ct1, const QColorTransform &ct2) + { return ct1.compare(ct2); } + friend bool operator!=(const QColorTransform &ct1, const QColorTransform &ct2) + { return !ct1.compare(ct2); } + private: - friend class QColorSpace; friend class QColorSpacePrivate; friend class QColorTransformPrivate; - friend class QImage; + Q_GUI_EXPORT bool compare(const QColorTransform &other) const; QExplicitlySharedDataPointer<QColorTransformPrivate> d; }; diff --git a/src/gui/painting/qcolortransform_p.h b/src/gui/painting/qcolortransform_p.h index 36420dcfdc..59ea6a2405 100644 --- a/src/gui/painting/qcolortransform_p.h +++ b/src/gui/painting/qcolortransform_p.h @@ -22,6 +22,7 @@ #include <QtGui/qrgbafloat.h> QT_BEGIN_NAMESPACE +class QCmyk32; class QColorTransformPrivate : public QSharedData { @@ -35,9 +36,10 @@ public: void updateLutsIn() const; void updateLutsOut() const; - bool simpleGammaCorrection() const; + bool isIdentity() const; + bool isThreeComponentMatrix() const; - void prepare(); + Q_GUI_EXPORT void prepare(); enum TransformFlag { Unpremultiplied = 0, InputOpaque = 1, @@ -47,19 +49,25 @@ public: }; Q_DECLARE_FLAGS(TransformFlags, TransformFlag) - void apply(QRgb *dst, const QRgb *src, qsizetype count, TransformFlags flags = Unpremultiplied) const; - void apply(QRgba64 *dst, const QRgba64 *src, qsizetype count, TransformFlags flags = Unpremultiplied) const; - void apply(QRgbaFloat32 *dst, const QRgbaFloat32 *src, qsizetype count, - TransformFlags flags = Unpremultiplied) const; - void apply(quint8 *dst, const QRgb *src, qsizetype count, TransformFlags flags = Unpremultiplied) const; - void apply(quint16 *dst, const QRgba64 *src, qsizetype count, TransformFlags flags = Unpremultiplied) const; - - template<typename T> - void apply(T *dst, const T *src, qsizetype count, TransformFlags flags) const; + QColorVector map(QColorVector color) const; + QColorVector mapExtended(QColorVector color) const; template<typename D, typename S> + void apply(D *dst, const S *src, qsizetype count, TransformFlags flags) const; + template<typename D, typename S> + void applyGray(D *dst, const S *src, qsizetype count, TransformFlags flags) const; + template<typename D, typename S> void applyReturnGray(D *dst, const S *src, qsizetype count, TransformFlags flags) const; +private: + template<typename S> + void applyConvertIn(const S *src, QColorVector *buffer, qsizetype len, TransformFlags flags) const; + template<typename D, typename S> + void applyConvertOut(D *dst, const S *src, QColorVector *buffer, qsizetype len, TransformFlags flags) const; + template<typename D, typename S> + void applyElementListTransform(D *dst, const S *src, qsizetype count, TransformFlags flags) const; + template<typename D, typename S> + void applyThreeComponentMatrix(D *dst, const S *src, qsizetype count, TransformFlags flags) const; }; QT_END_NAMESPACE diff --git a/src/gui/painting/qcolortrc_p.h b/src/gui/painting/qcolortrc_p.h index 9e879bb3e2..d1ad1987df 100644 --- a/src/gui/painting/qcolortrc_p.h +++ b/src/gui/painting/qcolortrc_p.h @@ -21,17 +21,15 @@ QT_BEGIN_NAMESPACE - -// Defines an ICC TRC (Tone Reproduction Curve) +// Defines a TRC (Tone Reproduction Curve) class Q_GUI_EXPORT QColorTrc { public: - QColorTrc() noexcept : m_type(Type::Uninitialized) - { } - QColorTrc(const QColorTransferFunction &fun) : m_type(Type::Function), m_fun(fun) - { } - QColorTrc(const QColorTransferTable &table) : m_type(Type::Table), m_table(table) - { } + QColorTrc() noexcept : m_type(Type::Uninitialized) { } + QColorTrc(const QColorTransferFunction &fun) : m_type(Type::Function), m_fun(fun) { } + QColorTrc(const QColorTransferTable &table) : m_type(Type::Table), m_table(table) { } + QColorTrc(QColorTransferFunction &&fun) noexcept : m_type(Type::Function), m_fun(std::move(fun)) { } + QColorTrc(QColorTransferTable &&table) noexcept : m_type(Type::Table), m_table(std::move(table)) { } enum class Type { Uninitialized, @@ -39,9 +37,10 @@ public: Table }; - bool isLinear() const + bool isIdentity() const { - return m_type == Type::Uninitialized || (m_type == Type::Function && m_fun.isLinear()); + return (m_type == Type::Function && m_fun.isIdentity()) + || (m_type == Type::Table && m_table.isIdentity()); } bool isValid() const { diff --git a/src/gui/painting/qcolortrclut.cpp b/src/gui/painting/qcolortrclut.cpp index 6f1cacea75..8a7673bc00 100644 --- a/src/gui/painting/qcolortrclut.cpp +++ b/src/gui/painting/qcolortrclut.cpp @@ -13,43 +13,80 @@ std::shared_ptr<QColorTrcLut> QColorTrcLut::create() return std::make_shared<Access>(); } -std::shared_ptr<QColorTrcLut> QColorTrcLut::fromGamma(qreal gamma) +std::shared_ptr<QColorTrcLut> QColorTrcLut::fromGamma(qreal gamma, Direction dir) { auto cp = create(); + cp->setFromGamma(gamma, dir); + return cp; +} - for (int i = 0; i <= (255 * 16); ++i) { - cp->m_toLinear[i] = ushort(qRound(qPow(i / qreal(255 * 16), gamma) * (255 * 256))); - cp->m_fromLinear[i] = ushort(qRound(qPow(i / qreal(255 * 16), qreal(1) / gamma) * (255 * 256))); - } - +std::shared_ptr<QColorTrcLut> QColorTrcLut::fromTransferFunction(const QColorTransferFunction &fun, Direction dir) +{ + auto cp = create(); + cp->setFromTransferFunction(fun, dir); return cp; } -std::shared_ptr<QColorTrcLut> QColorTrcLut::fromTransferFunction(const QColorTransferFunction &fun) +std::shared_ptr<QColorTrcLut> QColorTrcLut::fromTransferTable(const QColorTransferTable &table, Direction dir) { auto cp = create(); - QColorTransferFunction inv = fun.inverted(); + cp->setFromTransferTable(table, dir); + return cp; +} - for (int i = 0; i <= (255 * 16); ++i) { - cp->m_toLinear[i] = ushort(qRound(fun.apply(i / qreal(255 * 16)) * (255 * 256))); - cp->m_fromLinear[i] = ushort(qRound(inv.apply(i / qreal(255 * 16)) * (255 * 256))); +void QColorTrcLut::setFromGamma(qreal gamma, Direction dir) +{ + if (dir & ToLinear) { + if (!m_toLinear) + m_toLinear.reset(new ushort[Resolution + 1]); + for (int i = 0; i <= Resolution; ++i) + m_toLinear[i] = ushort(qRound(qPow(i / qreal(Resolution), gamma) * (255 * 256))); } - return cp; + if (dir & FromLinear) { + if (!m_fromLinear) + m_fromLinear.reset(new ushort[Resolution + 1]); + for (int i = 0; i <= Resolution; ++i) + m_fromLinear[i] = ushort(qRound(qPow(i / qreal(Resolution), qreal(1) / gamma) * (255 * 256))); + } } -std::shared_ptr<QColorTrcLut> QColorTrcLut::fromTransferTable(const QColorTransferTable &table) +void QColorTrcLut::setFromTransferFunction(const QColorTransferFunction &fun, Direction dir) { - auto cp = create(); + if (dir & ToLinear) { + if (!m_toLinear) + m_toLinear.reset(new ushort[Resolution + 1]); + for (int i = 0; i <= Resolution; ++i) + m_toLinear[i] = ushort(qRound(fun.apply(i / qreal(Resolution)) * (255 * 256))); + } - float minInverse = 0.0f; - for (int i = 0; i <= (255 * 16); ++i) { - cp->m_toLinear[i] = ushort(qBound(0, qRound(table.apply(i / qreal(255 * 16)) * (255 * 256)), 65280)); - minInverse = table.applyInverse(i / qreal(255 * 16), minInverse); - cp->m_fromLinear[i] = ushort(qBound(0, qRound(minInverse * (255 * 256)), 65280)); + if (dir & FromLinear) { + if (!m_fromLinear) + m_fromLinear.reset(new ushort[Resolution + 1]); + QColorTransferFunction inv = fun.inverted(); + for (int i = 0; i <= Resolution; ++i) + m_fromLinear[i] = ushort(qRound(inv.apply(i / qreal(Resolution)) * (255 * 256))); } +} - return cp; +void QColorTrcLut::setFromTransferTable(const QColorTransferTable &table, Direction dir) +{ + if (dir & ToLinear) { + if (!m_toLinear) + m_toLinear.reset(new ushort[Resolution + 1]); + for (int i = 0; i <= Resolution; ++i) + m_toLinear[i] = ushort(qBound(0, qRound(table.apply(i / qreal(Resolution)) * (255 * 256)), 65280)); + } + + if (dir & FromLinear) { + if (!m_fromLinear) + m_fromLinear.reset(new ushort[Resolution + 1]); + float minInverse = 0.0f; + for (int i = 0; i <= Resolution; ++i) { + minInverse = table.applyInverse(i / qreal(Resolution), minInverse); + m_fromLinear[i] = ushort(qBound(0, qRound(minInverse * (255 * 256)), 65280)); + } + } } QT_END_NAMESPACE diff --git a/src/gui/painting/qcolortrclut_p.h b/src/gui/painting/qcolortrclut_p.h index 1b312d4a78..3ebab42809 100644 --- a/src/gui/painting/qcolortrclut_p.h +++ b/src/gui/painting/qcolortrclut_p.h @@ -36,9 +36,22 @@ class QColorTransferTable; class Q_GUI_EXPORT QColorTrcLut { public: - static std::shared_ptr<QColorTrcLut> fromGamma(qreal gamma); - static std::shared_ptr<QColorTrcLut> fromTransferFunction(const QColorTransferFunction &transfn); - static std::shared_ptr<QColorTrcLut> fromTransferTable(const QColorTransferTable &transTable); + static constexpr uint32_t ShiftUp = 4; // Amount to shift up from 1->255 + static constexpr uint32_t ShiftDown = (8 - ShiftUp); // Amount to shift down from 1->65280 + static constexpr qsizetype Resolution = (1 << ShiftUp) * 255; // Number of entries in table + + enum Direction { + ToLinear = 1, + FromLinear = 2, + BiLinear = ToLinear | FromLinear + }; + + static std::shared_ptr<QColorTrcLut> fromGamma(qreal gamma, Direction dir = BiLinear); + static std::shared_ptr<QColorTrcLut> fromTransferFunction(const QColorTransferFunction &transFn, Direction dir = BiLinear); + static std::shared_ptr<QColorTrcLut> fromTransferTable(const QColorTransferTable &transTable, Direction dir = BiLinear); + void setFromGamma(qreal gamma, Direction dir = BiLinear); + void setFromTransferFunction(const QColorTransferFunction &transFn, Direction dir = BiLinear); + void setFromTransferTable(const QColorTransferTable &transTable, Direction dir = BiLinear); // The following methods all convert opaque or unpremultiplied colors: @@ -47,7 +60,7 @@ public: #if defined(__SSE2__) __m128i v = _mm_cvtsi32_si128(rgb32); v = _mm_unpacklo_epi8(v, _mm_setzero_si128()); - const __m128i vidx = _mm_slli_epi16(v, 4); + const __m128i vidx = _mm_slli_epi16(v, ShiftUp); const int ridx = _mm_extract_epi16(vidx, 2); const int gidx = _mm_extract_epi16(vidx, 1); const int bidx = _mm_extract_epi16(vidx, 0); @@ -62,7 +75,7 @@ public: #elif (defined(__ARM_NEON__) || defined(__ARM_NEON)) && Q_BYTE_ORDER == Q_LITTLE_ENDIAN uint8x8_t v8 = vreinterpret_u8_u32(vmov_n_u32(rgb32)); uint16x4_t v16 = vget_low_u16(vmovl_u8(v8)); - const uint16x4_t vidx = vshl_n_u16(v16, 4); + const uint16x4_t vidx = vshl_n_u16(v16, ShiftUp); const int ridx = vget_lane_u16(vidx, 2); const int gidx = vget_lane_u16(vidx, 1); const int bidx = vget_lane_u16(vidx, 0); @@ -73,42 +86,43 @@ public: v16 = vadd_u16(v16, vshr_n_u16(v16, 8)); return QRgba64::fromRgba64(vget_lane_u64(vreinterpret_u64_u16(v16), 0)); #else - uint r = m_toLinear[qRed(rgb32) << 4]; - uint g = m_toLinear[qGreen(rgb32) << 4]; - uint b = m_toLinear[qBlue(rgb32) << 4]; + uint r = m_toLinear[qRed(rgb32) << ShiftUp]; + uint g = m_toLinear[qGreen(rgb32) << ShiftUp]; + uint b = m_toLinear[qBlue(rgb32) << ShiftUp]; r = r + (r >> 8); g = g + (g >> 8); b = b + (b >> 8); return QRgba64::fromRgba64(r, g, b, qAlpha(rgb32) * 257); #endif } + QRgba64 toLinear64(QRgba64) const = delete; QRgb toLinear(QRgb rgb32) const { - return convertWithTable(rgb32, m_toLinear); + return convertWithTable(rgb32, m_toLinear.get()); } QRgba64 toLinear(QRgba64 rgb64) const { - return convertWithTable(rgb64, m_toLinear); + return convertWithTable(rgb64, m_toLinear.get()); } float u8ToLinearF32(int c) const { - ushort v = m_toLinear[c << 4]; + ushort v = m_toLinear[c << ShiftUp]; return v * (1.0f / (255*256)); } float u16ToLinearF32(int c) const { c -= (c >> 8); - ushort v = m_toLinear[c >> 4]; + ushort v = m_toLinear[c >> ShiftDown]; return v * (1.0f / (255*256)); } float toLinear(float f) const { - ushort v = m_toLinear[(int)(f * (255 * 16) + 0.5f)]; + ushort v = m_toLinear[(int)(f * Resolution + 0.5f)]; return v * (1.0f / (255*256)); } @@ -117,7 +131,7 @@ public: #if defined(__SSE2__) __m128i v = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&rgb64)); v = _mm_sub_epi16(v, _mm_srli_epi16(v, 8)); - const __m128i vidx = _mm_srli_epi16(v, 4); + const __m128i vidx = _mm_srli_epi16(v, ShiftDown); const int ridx = _mm_extract_epi16(vidx, 0); const int gidx = _mm_extract_epi16(vidx, 1); const int bidx = _mm_extract_epi16(vidx, 2); @@ -131,7 +145,7 @@ public: #elif (defined(__ARM_NEON__) || defined(__ARM_NEON)) && Q_BYTE_ORDER == Q_LITTLE_ENDIAN uint16x4_t v = vreinterpret_u16_u64(vmov_n_u64(rgb64)); v = vsub_u16(v, vshr_n_u16(v, 8)); - const uint16x4_t vidx = vshr_n_u16(v, 4); + const uint16x4_t vidx = vshr_n_u16(v, ShiftDown); const int ridx = vget_lane_u16(vidx, 0); const int gidx = vget_lane_u16(vidx, 1); const int bidx = vget_lane_u16(vidx, 2); @@ -150,56 +164,56 @@ public: g = g - (g >> 8); b = b - (b >> 8); a = (a + 0x80) >> 8; - r = (m_fromLinear[r >> 4] + 0x80) >> 8; - g = (m_fromLinear[g >> 4] + 0x80) >> 8; - b = (m_fromLinear[b >> 4] + 0x80) >> 8; + r = (m_fromLinear[r >> ShiftDown] + 0x80) >> 8; + g = (m_fromLinear[g >> ShiftDown] + 0x80) >> 8; + b = (m_fromLinear[b >> ShiftDown] + 0x80) >> 8; return (a << 24) | (r << 16) | (g << 8) | b; #endif } QRgb fromLinear(QRgb rgb32) const { - return convertWithTable(rgb32, m_fromLinear); + return convertWithTable(rgb32, m_fromLinear.get()); } QRgba64 fromLinear(QRgba64 rgb64) const { - return convertWithTable(rgb64, m_fromLinear); + return convertWithTable(rgb64, m_fromLinear.get()); } int u8FromLinearF32(float f) const { - ushort v = m_fromLinear[(int)(f * (255 * 16) + 0.5f)]; + ushort v = m_fromLinear[(int)(f * Resolution + 0.5f)]; return (v + 0x80) >> 8; } int u16FromLinearF32(float f) const { - ushort v = m_fromLinear[(int)(f * (255 * 16) + 0.5f)]; + ushort v = m_fromLinear[(int)(f * Resolution + 0.5f)]; return v + (v >> 8); } float fromLinear(float f) const { - ushort v = m_fromLinear[(int)(f * (255 * 16) + 0.5f)]; + ushort v = m_fromLinear[(int)(f * Resolution + 0.5f)]; return v * (1.0f / (255*256)); } // We translate to 0-65280 (255*256) instead to 0-65535 to make simple // shifting an accurate conversion. - // We translate from 0-4080 (255*16) for the same speed up, and to keep - // the tables small enough to fit in most inner caches. - ushort m_toLinear[(255 * 16) + 1]; // [0-4080] -> [0-65280] - ushort m_fromLinear[(255 * 16) + 1]; // [0-4080] -> [0-65280] + // We translate from 0->Resolution (4080 = 255*16) for the same speed up, + // and to keep the tables small enough to fit in most inner caches. + std::unique_ptr<ushort[]> m_toLinear; // [0->Resolution] -> [0-65280] + std::unique_ptr<ushort[]> m_fromLinear; // [0->Resolution] -> [0-65280] private: - QColorTrcLut() { } // force uninitialized members + QColorTrcLut() = default; static std::shared_ptr<QColorTrcLut> create(); Q_ALWAYS_INLINE static QRgb convertWithTable(QRgb rgb32, const ushort *table) { - const int r = (table[qRed(rgb32) << 4] + 0x80) >> 8; - const int g = (table[qGreen(rgb32) << 4] + 0x80) >> 8; - const int b = (table[qBlue(rgb32) << 4] + 0x80) >> 8; + const int r = (table[qRed(rgb32) << ShiftUp] + 0x80) >> 8; + const int g = (table[qGreen(rgb32) << ShiftUp] + 0x80) >> 8; + const int b = (table[qBlue(rgb32) << ShiftUp] + 0x80) >> 8; return (rgb32 & 0xff000000) | (r << 16) | (g << 8) | b; } Q_ALWAYS_INLINE static QRgba64 convertWithTable(QRgba64 rgb64, const ushort *table) @@ -207,7 +221,7 @@ private: #if defined(__SSE2__) __m128i v = _mm_loadl_epi64(reinterpret_cast<const __m128i *>(&rgb64)); v = _mm_sub_epi16(v, _mm_srli_epi16(v, 8)); - const __m128i vidx = _mm_srli_epi16(v, 4); + const __m128i vidx = _mm_srli_epi16(v, ShiftDown); const int ridx = _mm_extract_epi16(vidx, 2); const int gidx = _mm_extract_epi16(vidx, 1); const int bidx = _mm_extract_epi16(vidx, 0); @@ -221,7 +235,7 @@ private: #elif (defined(__ARM_NEON__) || defined(__ARM_NEON)) && Q_BYTE_ORDER == Q_LITTLE_ENDIAN uint16x4_t v = vreinterpret_u16_u64(vmov_n_u64(rgb64)); v = vsub_u16(v, vshr_n_u16(v, 8)); - const uint16x4_t vidx = vshr_n_u16(v, 4); + const uint16x4_t vidx = vshr_n_u16(v, ShiftDown); const int ridx = vget_lane_u16(vidx, 2); const int gidx = vget_lane_u16(vidx, 1); const int bidx = vget_lane_u16(vidx, 0); @@ -237,9 +251,9 @@ private: r = r - (r >> 8); g = g - (g >> 8); b = b - (b >> 8); - r = table[r >> 4]; - g = table[g >> 4]; - b = table[b >> 4]; + r = table[r >> ShiftDown]; + g = table[g >> ShiftDown]; + b = table[b >> ShiftDown]; r = r + (r >> 8); g = g + (g >> 8); b = b + (b >> 8); diff --git a/src/gui/painting/qcompositionfunctions.cpp b/src/gui/painting/qcompositionfunctions.cpp index 46e1a812fc..00fd749fe6 100644 --- a/src/gui/painting/qcompositionfunctions.cpp +++ b/src/gui/painting/qcompositionfunctions.cpp @@ -397,25 +397,25 @@ struct RgbaFPOperationsSSE2 : public RgbaFPOperationsBase typedef __m128 OptimalType; typedef __m128 OptimalScalar; - static OptimalType load(const Type *ptr) + static OptimalType Q_DECL_VECTORCALL load(const Type *ptr) { - return _mm_load_ps(reinterpret_cast<const float *>(ptr)); + return _mm_loadu_ps(reinterpret_cast<const float *>(ptr)); } - static OptimalType convert(const Type &value) + static OptimalType Q_DECL_VECTORCALL convert(const Type &value) { return load(&value); } - static void store(Type *ptr, OptimalType value) + static void Q_DECL_VECTORCALL store(Type *ptr, OptimalType value) { - _mm_store_ps(reinterpret_cast<float *>(ptr), value); + _mm_storeu_ps(reinterpret_cast<float *>(ptr), value); } - static OptimalType add(OptimalType a, OptimalType b) + static OptimalType Q_DECL_VECTORCALL add(OptimalType a, OptimalType b) { return _mm_add_ps(a, b); } // same as above: // static OptimalScalar add(OptimalScalar a, OptimalScalar b) - static OptimalType plus(OptimalType a, OptimalType b) + static OptimalType Q_DECL_VECTORCALL plus(OptimalType a, OptimalType b) { a = _mm_add_ps(a, b); __m128 aa = _mm_min_ps(a, _mm_set1_ps(1.0f)); @@ -425,37 +425,37 @@ struct RgbaFPOperationsSSE2 : public RgbaFPOperationsBase a = _mm_shuffle_ps(a, aa, _MM_SHUFFLE(0, 2, 1, 0)); return a; } - static OptimalScalar alpha(OptimalType c) + static OptimalScalar Q_DECL_VECTORCALL alpha(OptimalType c) { return _mm_shuffle_ps(c, c, _MM_SHUFFLE(3, 3, 3, 3)); } - static OptimalScalar invAlpha(Scalar c) + static OptimalScalar Q_DECL_VECTORCALL invAlpha(Scalar c) { return _mm_set1_ps(1.0f - float(c)); } - static OptimalScalar invAlpha(OptimalType c) + static OptimalScalar Q_DECL_VECTORCALL invAlpha(OptimalType c) { return _mm_sub_ps(_mm_set1_ps(1.0f), alpha(c)); } - static OptimalScalar scalar(Scalar n) + static OptimalScalar Q_DECL_VECTORCALL scalar(Scalar n) { return _mm_set1_ps(float(n)); } - static OptimalType multiplyAlpha(OptimalType val, OptimalScalar a) + static OptimalType Q_DECL_VECTORCALL multiplyAlpha(OptimalType val, OptimalScalar a) { return _mm_mul_ps(val, a); } - static OptimalType interpolate(OptimalType x, OptimalScalar a1, OptimalType y, OptimalScalar a2) + static OptimalType Q_DECL_VECTORCALL interpolate(OptimalType x, OptimalScalar a1, OptimalType y, OptimalScalar a2) { return add(multiplyAlpha(x, a1), multiplyAlpha(y, a2)); } - static OptimalType multiplyAlpha8bit(OptimalType val, uint8_t a) + static OptimalType Q_DECL_VECTORCALL multiplyAlpha8bit(OptimalType val, uint8_t a) { return multiplyAlpha(val, _mm_set1_ps(a * (1.0f / 255.0f))); } // same as above: // static OptimalScalar multiplyAlpha8bit(OptimalScalar a, uint8_t a) - static OptimalType interpolate8bit(OptimalType x, uint8_t a1, OptimalType y, uint8_t a2) + static OptimalType Q_DECL_VECTORCALL interpolate8bit(OptimalType x, uint8_t a1, OptimalType y, uint8_t a2) { return add(multiplyAlpha8bit(x, a1), multiplyAlpha8bit(y, a2)); } diff --git a/src/gui/painting/qcoregraphics.mm b/src/gui/painting/qcoregraphics.mm index ed44efc5ec..27b46202f5 100644 --- a/src/gui/painting/qcoregraphics.mm +++ b/src/gui/painting/qcoregraphics.mm @@ -132,7 +132,7 @@ QT_END_NAMESPACE auto nsImage = [[[NSImage alloc] initWithSize:NSZeroSize] autorelease]; - for (QSize size : qAsConst(availableSizes)) { + for (QSize size : std::as_const(availableSizes)) { QImage image = icon.pixmap(size).toImage(); if (image.isNull()) continue; @@ -162,6 +162,9 @@ QT_BEGIN_NAMESPACE QPixmap qt_mac_toQPixmap(const NSImage *image, const QSizeF &size) { + // ### TODO: add parameter so that we can decide whether to maintain the aspect + // ratio of the image (positioning the image inside the pixmap of size \a size), + // or whether we want to fill the resulting pixmap by stretching the image. const NSSize pixmapSize = NSMakeSize(size.width(), size.height()); QPixmap pixmap(pixmapSize.width, pixmapSize.height); pixmap.fill(Qt::transparent); @@ -182,6 +185,25 @@ QPixmap qt_mac_toQPixmap(const NSImage *image, const QSizeF &size) #endif // Q_OS_MACOS +#ifdef QT_PLATFORM_UIKIT + +QImage qt_mac_toQImage(const UIImage *image, QSizeF size) +{ + // ### TODO: same as above + QImage ret(size.width(), size.height(), QImage::Format_ARGB32_Premultiplied); + ret.fill(Qt::transparent); + QMacCGContext ctx(&ret); + if (!ctx) + return QImage(); + UIGraphicsPushContext(ctx); + const CGRect rect = CGRectMake(0, 0, size.width(), size.height()); + [image drawInRect:rect]; + UIGraphicsPopContext(); + return ret; +} + +#endif // QT_PLATFORM_UIKIT + // ---------------------- Colors and Brushes ---------------------- QColor qt_mac_toQColor(CGColorRef color) @@ -386,11 +408,14 @@ void QMacCGContext::initialize(QPaintDevice *paintDevice) // Find the underlying QImage of the paint device switch (int deviceType = paintDevice->devType()) { case QInternal::Pixmap: { - auto *platformPixmap = static_cast<QPixmap*>(paintDevice)->handle(); - if (platformPixmap && platformPixmap->classId() == QPlatformPixmap::RasterClass) - initialize(platformPixmap->buffer()); - else - qWarning() << "QMacCGContext: Unsupported pixmap class" << platformPixmap->classId(); + if (auto *platformPixmap = static_cast<QPixmap*>(paintDevice)->handle()) { + if (platformPixmap->classId() == QPlatformPixmap::RasterClass) + initialize(platformPixmap->buffer()); + else + qWarning() << "QMacCGContext: Unsupported pixmap class" << platformPixmap->classId(); + } else { + qWarning() << "QMacCGContext: Empty platformPixmap"; + } break; } case QInternal::Image: diff --git a/src/gui/painting/qcoregraphics_p.h b/src/gui/painting/qcoregraphics_p.h index f0640ba500..a35f27a730 100644 --- a/src/gui/painting/qcoregraphics_p.h +++ b/src/gui/painting/qcoregraphics_p.h @@ -23,16 +23,23 @@ #include <CoreGraphics/CoreGraphics.h> -#if defined(__OBJC__) && defined(Q_OS_MACOS) -#include <AppKit/AppKit.h> -#define HAVE_APPKIT +#if defined(__OBJC__) +# if defined(Q_OS_MACOS) +# include <AppKit/AppKit.h> +# elif defined(QT_PLATFORM_UIKIT) +# include <UIKit/UIKit.h> +# endif #endif QT_BEGIN_NAMESPACE Q_GUI_EXPORT CGBitmapInfo qt_mac_bitmapInfoForImage(const QImage &image); -#ifdef HAVE_APPKIT +#ifdef QT_PLATFORM_UIKIT +Q_GUI_EXPORT QImage qt_mac_toQImage(const UIImage *image, QSizeF size); +#endif + +#ifdef Q_OS_MACOS Q_GUI_EXPORT QPixmap qt_mac_toQPixmap(const NSImage *image, const QSizeF &size); QT_END_NAMESPACE @@ -57,7 +64,7 @@ Q_GUI_EXPORT void qt_mac_drawCGImage(CGContextRef inContext, const CGRect *inBou Q_GUI_EXPORT void qt_mac_clip_cg(CGContextRef hd, const QRegion &rgn, CGAffineTransform *orig_xform); -#ifdef HAVE_APPKIT +#ifdef Q_OS_MACOS Q_GUI_EXPORT QColor qt_mac_toQColor(const NSColor *color); Q_GUI_EXPORT QBrush qt_mac_toQBrush(const NSColor *color, QPalette::ColorGroup colorGroup = QPalette::Normal); #endif @@ -81,6 +88,4 @@ private: QT_END_NAMESPACE -#undef HAVE_APPKIT - #endif // QCOREGRAPHICS_P_H diff --git a/src/gui/painting/qcosmeticstroker.cpp b/src/gui/painting/qcosmeticstroker.cpp index f555b56adb..a0eddf65d9 100644 --- a/src/gui/painting/qcosmeticstroker.cpp +++ b/src/gui/painting/qcosmeticstroker.cpp @@ -364,7 +364,7 @@ void QCosmeticStroker::drawPoints(const QPoint *points, int num) const QPoint *end = points + num; while (points < end) { QPointF p = QPointF(*points) * state->matrix; - drawPixel(this, qRound(p.x()), qRound(p.y()), 255); + drawPixel(this, std::floor(p.x()), std::floor(p.y()), 255); ++points; } @@ -377,7 +377,7 @@ void QCosmeticStroker::drawPoints(const QPointF *points, int num) const QPointF *end = points + num; while (points < end) { QPointF p = (*points) * state->matrix; - drawPixel(this, qRound(p.x()), qRound(p.y()), 255); + drawPixel(this, std::floor(p.x()), std::floor(p.y()), 255); ++points; } diff --git a/src/gui/painting/qcssutil.cpp b/src/gui/painting/qcssutil.cpp index db9b7c24fe..caface7d1a 100644 --- a/src/gui/painting/qcssutil.cpp +++ b/src/gui/painting/qcssutil.cpp @@ -168,28 +168,28 @@ void qDrawEdge(QPainter *p, qreal x1, qreal y1, qreal x2, qreal y2, qreal dw1, q if (width == 1 || (dw1 == 0 && dw2 == 0)) { p->drawRect(QRectF(x1, y1, x2-x1, y2-y1)); } else { // draw trapezoid - QPolygonF quad; + std::array<QPointF, 4> quad; switch (edge) { case TopEdge: - quad << QPointF(x1, y1) << QPointF(x1 + dw1, y2) - << QPointF(x2 - dw2, y2) << QPointF(x2, y1); + quad = {QPointF(x1, y1), QPointF(x1 + dw1, y2), + QPointF(x2 - dw2, y2), QPointF(x2, y1)}; break; case BottomEdge: - quad << QPointF(x1 + dw1, y1) << QPointF(x1, y2) - << QPointF(x2, y2) << QPointF(x2 - dw2, y1); + quad = {QPointF(x1 + dw1, y1), QPointF(x1, y2), + QPointF(x2, y2), QPointF(x2 - dw2, y1)}; break; case LeftEdge: - quad << QPointF(x1, y1) << QPointF(x1, y2) - << QPointF(x2, y2 - dw2) << QPointF(x2, y1 + dw1); + quad = {QPointF(x1, y1), QPointF(x1, y2), + QPointF(x2, y2 - dw2), QPointF(x2, y1 + dw1)}; break; case RightEdge: - quad << QPointF(x1, y1 + dw1) << QPointF(x1, y2 - dw2) - << QPointF(x2, y2) << QPointF(x2, y1); + quad = {QPointF(x1, y1 + dw1), QPointF(x1, y2 - dw2), + QPointF(x2, y2), QPointF(x2, y1)}; break; default: break; } - p->drawConvexPolygon(quad); + p->drawConvexPolygon(quad.data(), static_cast<int>(quad.size())); } break; } @@ -268,6 +268,7 @@ void qDrawEdge(QPainter *p, qreal x1, qreal y1, qreal x2, qreal y2, qreal dw1, q default: break; } + break; } default: break; diff --git a/src/gui/painting/qdatabuffer_p.h b/src/gui/painting/qdatabuffer_p.h index b8bb44de6c..8f467afe4e 100644 --- a/src/gui/painting/qdatabuffer_p.h +++ b/src/gui/painting/qdatabuffer_p.h @@ -26,7 +26,7 @@ template <typename Type> class QDataBuffer { Q_DISABLE_COPY_MOVE(QDataBuffer) public: - QDataBuffer(int res) + explicit QDataBuffer(qsizetype res) { capacity = res; if (res) { @@ -51,11 +51,11 @@ public: inline bool isEmpty() const { return siz==0; } - inline int size() const { return siz; } + qsizetype size() const { return siz; } inline Type *data() const { return buffer; } - inline Type &at(int i) { Q_ASSERT(i >= 0 && i < siz); return buffer[i]; } - inline const Type &at(int i) const { Q_ASSERT(i >= 0 && i < siz); return buffer[i]; } + Type &at(qsizetype i) { Q_ASSERT(i >= 0 && i < siz); return buffer[i]; } + const Type &at(qsizetype i) const { Q_ASSERT(i >= 0 && i < siz); return buffer[i]; } inline Type &last() { Q_ASSERT(!isEmpty()); return buffer[siz-1]; } inline const Type &last() const { Q_ASSERT(!isEmpty()); return buffer[siz-1]; } inline Type &first() { Q_ASSERT(!isEmpty()); return buffer[0]; } @@ -72,12 +72,12 @@ public: --siz; } - inline void resize(int size) { + void resize(qsizetype size) { reserve(size); siz = size; } - inline void reserve(int size) { + void reserve(qsizetype size) { if (size > capacity) { if (capacity == 0) capacity = 1; @@ -88,14 +88,17 @@ public: } } - inline void shrink(int size) { + void shrink(qsizetype size) { + Q_ASSERT(capacity >= size); capacity = size; if (size) { buffer = (Type*) realloc(static_cast<void*>(buffer), capacity * sizeof(Type)); Q_CHECK_PTR(buffer); + siz = std::min(siz, size); } else { free(buffer); buffer = nullptr; + siz = 0; } } @@ -108,8 +111,8 @@ public: inline QDataBuffer &operator<<(const Type &t) { add(t); return *this; } private: - int capacity; - int siz; + qsizetype capacity; + qsizetype siz; Type *buffer; }; diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp index 6e498bc2e3..b7a943be38 100644 --- a/src/gui/painting/qdrawhelper.cpp +++ b/src/gui/painting/qdrawhelper.cpp @@ -32,6 +32,7 @@ #if defined(QT_USE_THREAD_PARALLEL_FILLS) #include <qsemaphore.h> #include <qthreadpool.h> +#include <private/qthreadpool_p.h> #endif QT_BEGIN_NAMESPACE @@ -50,8 +51,7 @@ constexpr int half_point = 1 << 15; template <QPixelLayout::BPP bpp> static inline uint QT_FASTCALL fetch1Pixel(const uchar *, int) { - Q_UNREACHABLE(); - return 0; + Q_UNREACHABLE_RETURN(0); } template <> @@ -176,7 +176,7 @@ static void QT_FASTCALL convertRGBA32FPMToRGBA64PM(QRgba64 *buffer, int count) } } -static Convert64Func convert64ToRGBA64PM[QImage::NImageFormats] = { +static Convert64Func convert64ToRGBA64PM[] = { nullptr, nullptr, nullptr, @@ -213,7 +213,10 @@ static Convert64Func convert64ToRGBA64PM[QImage::NImageFormats] = { convertRGBA32FPMToRGBA64PM, convertRGBA32FToRGBA64PM, convertRGBA32FPMToRGBA64PM, + nullptr, }; + +static_assert(std::size(convert64ToRGBA64PM) == QImage::NImageFormats); #endif #if QT_CONFIG(raster_fp) @@ -247,7 +250,7 @@ static void QT_FASTCALL convertRGBA16FToRGBA32F(QRgbaFloat32 *buffer, const quin qFloatFromFloat16((float *)buffer, (const qfloat16 *)src, count * 4); } -static Convert64ToFPFunc convert64ToRGBA32F[QImage::NImageFormats] = { +static Convert64ToFPFunc convert64ToRGBA32F[] = { nullptr, nullptr, nullptr, @@ -284,8 +287,11 @@ static Convert64ToFPFunc convert64ToRGBA32F[QImage::NImageFormats] = { nullptr, nullptr, nullptr, + nullptr, }; +static_assert(std::size(convert64ToRGBA32F) == QImage::NImageFormats); + static void convertRGBA32FToRGBA32FPM(QRgbaFloat32 *buffer, int count) { for (int i = 0; i < count; ++i) @@ -353,7 +359,7 @@ static uint *QT_FASTCALL destFetchUndefined(uint *buffer, QRasterBuffer *, int, return buffer; } -static DestFetchProc destFetchProc[QImage::NImageFormats] = +static DestFetchProc destFetchProc[] = { nullptr, // Format_Invalid destFetchMono, // Format_Mono, @@ -391,8 +397,11 @@ static DestFetchProc destFetchProc[QImage::NImageFormats] = destFetch, // Format_RGBX32FPx4 destFetch, // Format_RGBA32FPx4 destFetch, // Format_RGBA32FPx4_Premultiplied + destFetch, // Format_CMYK8888 }; +static_assert(std::size(destFetchProc) == QImage::NImageFormats); + #if QT_CONFIG(raster_64bit) static QRgba64 *QT_FASTCALL destFetch64(QRgba64 *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length) { @@ -410,7 +419,7 @@ static QRgba64 * QT_FASTCALL destFetch64Undefined(QRgba64 *buffer, QRasterBuffer return buffer; } -static DestFetchProc64 destFetchProc64[QImage::NImageFormats] = +static DestFetchProc64 destFetchProc64[] = { nullptr, // Format_Invalid nullptr, // Format_Mono, @@ -448,7 +457,10 @@ static DestFetchProc64 destFetchProc64[QImage::NImageFormats] = destFetch64, // Format_RGBX32FPx4 destFetch64, // Format_RGBA32FPx4 destFetch64, // Format_RGBA32FPx4_Premultiplied + destFetch64, // Format_CMYK8888 }; + +static_assert(std::size(destFetchProc64) == QImage::NImageFormats); #endif #if QT_CONFIG(raster_fp) @@ -466,7 +478,7 @@ static QRgbaFloat32 *QT_FASTCALL destFetchFPUndefined(QRgbaFloat32 *buffer, QRas { return buffer; } -static DestFetchProcFP destFetchProcFP[QImage::NImageFormats] = +static DestFetchProcFP destFetchProcFP[] = { nullptr, // Format_Invalid nullptr, // Format_Mono, @@ -504,7 +516,10 @@ static DestFetchProcFP destFetchProcFP[QImage::NImageFormats] = destFetchRGBFP, // Format_RGBX32FPx4 destFetchFP, // Format_RGBA32FPx4 destFetchRGBFP, // Format_RGBA32FPx4_Premultiplied + destFetchFP, // Format_CMYK8888 }; + +static_assert(std::size(destFetchProcFP) == QImage::NImageFormats); #endif /* @@ -513,9 +528,8 @@ static DestFetchProcFP destFetchProcFP[QImage::NImageFormats] = */ static inline QRgb findNearestColor(QRgb color, QRasterBuffer *rbuf) { - QRgb color_0 = qPremultiply(rbuf->destColor0); - QRgb color_1 = qPremultiply(rbuf->destColor1); - color = qPremultiply(color); + const QRgb color_0 = rbuf->destColor0; + const QRgb color_1 = rbuf->destColor1; int r = qRed(color); int g = qGreen(color); @@ -630,7 +644,7 @@ static void QT_FASTCALL destStoreGray8(QRasterBuffer *rasterBuffer, int x, int y QColorTransform tf = QColorSpacePrivate::get(fromCS)->transformationToXYZ(); QColorTransformPrivate *tfd = QColorTransformPrivate::get(tf); - tfd->apply(data, buffer, length, QColorTransformPrivate::InputPremultiplied); + tfd->applyReturnGray(data, buffer, length, QColorTransformPrivate::InputPremultiplied); } } @@ -654,11 +668,11 @@ static void QT_FASTCALL destStoreGray16(QRasterBuffer *rasterBuffer, int x, int QRgba64 tmp_line[BufferSize]; for (int k = 0; k < length; ++k) tmp_line[k] = QRgba64::fromArgb32(buffer[k]); - tfd->apply(data, tmp_line, length, QColorTransformPrivate::InputPremultiplied); + tfd->applyReturnGray(data, tmp_line, length, QColorTransformPrivate::InputPremultiplied); } } -static DestStoreProc destStoreProc[QImage::NImageFormats] = +static DestStoreProc destStoreProc[] = { nullptr, // Format_Invalid destStoreMono, // Format_Mono, @@ -696,8 +710,11 @@ static DestStoreProc destStoreProc[QImage::NImageFormats] = destStore, // Format_RGBX32FPx4 destStore, // Format_RGBA32FPx4 destStore, // Format_RGBA32FPx4_Premultiplied + destStore, // Format_CMYK8888 }; +static_assert(std::size(destStoreProc) == QImage::NImageFormats); + #if QT_CONFIG(raster_64bit) static void QT_FASTCALL destStore64(QRasterBuffer *rasterBuffer, int x, int y, const QRgba64 *buffer, int length) { @@ -732,7 +749,7 @@ static void QT_FASTCALL destStore64Gray8(QRasterBuffer *rasterBuffer, int x, int QColorTransformPrivate *tfd = QColorTransformPrivate::get(tf); quint16 gray_line[BufferSize]; - tfd->apply(gray_line, buffer, length, QColorTransformPrivate::InputPremultiplied); + tfd->applyReturnGray(gray_line, buffer, length, QColorTransformPrivate::InputPremultiplied); for (int k = 0; k < length; ++k) data[k] = qt_div_257(gray_line[k]); } @@ -754,11 +771,11 @@ static void QT_FASTCALL destStore64Gray16(QRasterBuffer *rasterBuffer, int x, in QColorSpace fromCS = rasterBuffer->colorSpace.isValid() ? rasterBuffer->colorSpace : QColorSpace::SRgb; QColorTransform tf = QColorSpacePrivate::get(fromCS)->transformationToXYZ(); QColorTransformPrivate *tfd = QColorTransformPrivate::get(tf); - tfd->apply(data, buffer, length, QColorTransformPrivate::InputPremultiplied); + tfd->applyReturnGray(data, buffer, length, QColorTransformPrivate::InputPremultiplied); } } -static DestStoreProc64 destStoreProc64[QImage::NImageFormats] = +static DestStoreProc64 destStoreProc64[] = { nullptr, // Format_Invalid nullptr, // Format_Mono, @@ -796,7 +813,10 @@ static DestStoreProc64 destStoreProc64[QImage::NImageFormats] = destStore64, // Format_RGBX32FPx4 destStore64, // Format_RGBA32FPx4 destStore64, // Format_RGBA32FPx4_Premultiplied + destStore64, // Format_CMYK8888 }; + +static_assert(std::size(destStoreProc64) == QImage::NImageFormats); #endif #if QT_CONFIG(raster_fp) @@ -3071,7 +3091,7 @@ static const QRgbaFloat32 *QT_FASTCALL fetchTransformedBilinearFP(QRgbaFloat32 * #endif // QT_CONFIG(raster_fp) // FetchUntransformed can have more specialized methods added depending on SIMD features. -static SourceFetchProc sourceFetchUntransformed[QImage::NImageFormats] = { +static SourceFetchProc sourceFetchUntransformed[] = { nullptr, // Invalid fetchUntransformed, // Mono fetchUntransformed, // MonoLsb @@ -3108,9 +3128,12 @@ static SourceFetchProc sourceFetchUntransformed[QImage::NImageFormats] = { fetchUntransformed, // RGBX32Px4 fetchUntransformed, // RGBA32FPx4 fetchUntransformed, // RGBA32FPx4_Premultiplied + fetchUntransformed, // CMYK8888 }; -static const SourceFetchProc sourceFetchGeneric[NBlendTypes] = { +static_assert(std::size(sourceFetchUntransformed) == QImage::NImageFormats); + +static const SourceFetchProc sourceFetchGeneric[] = { fetchUntransformed, // Untransformed fetchUntransformed, // Tiled fetchTransformed<BlendTransformed, QPixelLayout::BPPNone>, // Transformed @@ -3119,7 +3142,9 @@ static const SourceFetchProc sourceFetchGeneric[NBlendTypes] = { fetchTransformedBilinear<BlendTransformedBilinearTiled, QPixelLayout::BPPNone> // TransformedBilinearTiled }; -static SourceFetchProc sourceFetchARGB32PM[NBlendTypes] = { +static_assert(std::size(sourceFetchGeneric) == NBlendTypes); + +static SourceFetchProc sourceFetchARGB32PM[] = { fetchUntransformedARGB32PM, // Untransformed fetchUntransformedARGB32PM, // Tiled fetchTransformed<BlendTransformed, QPixelLayout::BPP32>, // Transformed @@ -3128,7 +3153,9 @@ static SourceFetchProc sourceFetchARGB32PM[NBlendTypes] = { fetchTransformedBilinearARGB32PM<BlendTransformedBilinearTiled> // BilinearTiled }; -static SourceFetchProc sourceFetchAny16[NBlendTypes] = { +static_assert(std::size(sourceFetchARGB32PM) == NBlendTypes); + +static SourceFetchProc sourceFetchAny16[] = { fetchUntransformed, // Untransformed fetchUntransformed, // Tiled fetchTransformed<BlendTransformed, QPixelLayout::BPP16>, // Transformed @@ -3137,7 +3164,9 @@ static SourceFetchProc sourceFetchAny16[NBlendTypes] = { fetchTransformedBilinear<BlendTransformedBilinearTiled, QPixelLayout::BPP16> // TransformedBilinearTiled }; -static SourceFetchProc sourceFetchAny32[NBlendTypes] = { +static_assert(std::size(sourceFetchAny16) == NBlendTypes); + +static SourceFetchProc sourceFetchAny32[] = { fetchUntransformed, // Untransformed fetchUntransformed, // Tiled fetchTransformed<BlendTransformed, QPixelLayout::BPP32>, // Transformed @@ -3146,6 +3175,8 @@ static SourceFetchProc sourceFetchAny32[NBlendTypes] = { fetchTransformedBilinear<BlendTransformedBilinearTiled, QPixelLayout::BPP32> // TransformedBilinearTiled }; +static_assert(std::size(sourceFetchAny32) == NBlendTypes); + static inline SourceFetchProc getSourceFetch(TextureBlendType blendType, QImage::Format format) { if (format == QImage::Format_RGB32 || format == QImage::Format_ARGB32_Premultiplied) @@ -3160,7 +3191,7 @@ static inline SourceFetchProc getSourceFetch(TextureBlendType blendType, QImage: } #if QT_CONFIG(raster_64bit) -static const SourceFetchProc64 sourceFetchGeneric64[NBlendTypes] = { +static const SourceFetchProc64 sourceFetchGeneric64[] = { fetchUntransformed64, // Untransformed fetchUntransformed64, // Tiled fetchTransformed64<BlendTransformed>, // Transformed @@ -3169,7 +3200,9 @@ static const SourceFetchProc64 sourceFetchGeneric64[NBlendTypes] = { fetchTransformedBilinear64<BlendTransformedBilinearTiled> // BilinearTiled }; -static const SourceFetchProc64 sourceFetchRGBA64PM[NBlendTypes] = { +static_assert(std::size(sourceFetchGeneric64) == NBlendTypes); + +static const SourceFetchProc64 sourceFetchRGBA64PM[] = { fetchUntransformedRGBA64PM, // Untransformed fetchUntransformedRGBA64PM, // Tiled fetchTransformed64<BlendTransformed>, // Transformed @@ -3178,6 +3211,8 @@ static const SourceFetchProc64 sourceFetchRGBA64PM[NBlendTypes] = { fetchTransformedBilinear64<BlendTransformedBilinearTiled> // BilinearTiled }; +static_assert(std::size(sourceFetchRGBA64PM) == NBlendTypes); + static inline SourceFetchProc64 getSourceFetch64(TextureBlendType blendType, QImage::Format format) { if (format == QImage::Format_RGBX64 || format == QImage::Format_RGBA64_Premultiplied) @@ -3187,7 +3222,7 @@ static inline SourceFetchProc64 getSourceFetch64(TextureBlendType blendType, QIm #endif #if QT_CONFIG(raster_fp) -static const SourceFetchProcFP sourceFetchGenericFP[NBlendTypes] = { +static const SourceFetchProcFP sourceFetchGenericFP[] = { fetchUntransformedFP, // Untransformed fetchUntransformedFP, // Tiled fetchTransformedFP<BlendTransformed>, // Transformed @@ -3196,6 +3231,8 @@ static const SourceFetchProcFP sourceFetchGenericFP[NBlendTypes] = { fetchTransformedBilinearFP<BlendTransformedBilinearTiled> // BilinearTiled }; +static_assert(std::size(sourceFetchGenericFP) == NBlendTypes); + static inline SourceFetchProcFP getSourceFetchFP(TextureBlendType blendType, QImage::Format /*format*/) { return sourceFetchGenericFP[blendType]; @@ -3256,6 +3293,7 @@ public: static Type null() { return 0; } static Type fetchSingle(const QGradientData& gradient, qreal v) { + Q_ASSERT(std::isfinite(v)); return qt_gradient_pixel(&gradient, v); } static Type fetchSingle(const QGradientData& gradient, int v) @@ -3276,6 +3314,7 @@ public: static Type null() { return QRgba64::fromRgba64(0); } static Type fetchSingle(const QGradientData& gradient, qreal v) { + Q_ASSERT(std::isfinite(v)); return qt_gradient_pixel64(&gradient, v); } static Type fetchSingle(const QGradientData& gradient, int v) @@ -3297,6 +3336,7 @@ public: static Type null() { return QRgbaFloat32::fromRgba64(0,0,0,0); } static Type fetchSingle(const QGradientData& gradient, qreal v) { + Q_ASSERT(std::isfinite(v)); return qt_gradient_pixelFP(&gradient, v); } static Type fetchSingle(const QGradientData& gradient, int v) @@ -3414,7 +3454,6 @@ static void QT_FASTCALL getRadialGradientValues(RadialGradientValues *v, const Q v->sqrfr = data->gradient.radial.focal.radius * data->gradient.radial.focal.radius; v->a = v->dr * v->dr - v->dx*v->dx - v->dy*v->dy; - v->inv2a = 1 / (2 * v->a); v->extended = !qFuzzyIsNull(data->gradient.radial.focal.radius) || v->a <= 0; } @@ -3447,7 +3486,13 @@ public: } } else { while (buffer < end) { - *buffer++ = GradientBase::fetchSingle(data->gradient, qSqrt(det) - b); + BlendType result = GradientBase::null(); + if (det >= 0) { + qreal w = qSqrt(det) - b; + result = GradientBase::fetchSingle(data->gradient, w); + } + + *buffer++ = result; det += delta_det; delta_det += delta_delta_det; @@ -3581,31 +3626,30 @@ static const CompositionFunctionFP *functionForModeFP = qt_functionForModeFP_C; static TextureBlendType getBlendType(const QSpanData *data) { TextureBlendType ft; - if (data->txop <= QTransform::TxTranslate) - if (data->texture.type == QTextureData::Tiled || data->texture.type == QTextureData::Pattern) + if (data->texture.type == QTextureData::Pattern) + ft = BlendTiled; + else if (data->txop <= QTransform::TxTranslate) + if (data->texture.type == QTextureData::Tiled) ft = BlendTiled; else ft = BlendUntransformed; else if (data->bilinear) - if (data->texture.type == QTextureData::Tiled || data->texture.type == QTextureData::Pattern) + if (data->texture.type == QTextureData::Tiled) ft = BlendTransformedBilinearTiled; else ft = BlendTransformedBilinear; else - if (data->texture.type == QTextureData::Pattern) - ft = BlendTiled; - else if (data->texture.type == QTextureData::Tiled) + if (data->texture.type == QTextureData::Tiled) ft = BlendTransformedTiled; else ft = BlendTransformed; return ft; } -static inline Operator getOperator(const QSpanData *data, const QSpan *spans, int spanCount) +static inline Operator getOperator(const QSpanData *data, const QT_FT_Span *spans, int spanCount) { Operator op; bool solidSource = false; - switch(data->type) { case QSpanData::Solid: solidSource = data->solidColor.alphaF() >= 1.0f; @@ -3649,7 +3693,7 @@ static inline Operator getOperator(const QSpanData *data, const QSpan *spans, in solidSource = !data->texture.hasAlpha; op.srcFetch = getSourceFetch(getBlendType(data), data->texture.format); #if QT_CONFIG(raster_64bit) - op.srcFetch64 = getSourceFetch64(getBlendType(data), data->texture.format);; + op.srcFetch64 = getSourceFetch64(getBlendType(data), data->texture.format); #endif #if QT_CONFIG(raster_fp) op.srcFetchFP = getSourceFetchFP(getBlendType(data), data->texture.format); @@ -3683,7 +3727,7 @@ static inline Operator getOperator(const QSpanData *data, const QSpan *spans, in #endif if (op.mode == QPainter::CompositionMode_Source && (data->type != QSpanData::Texture || data->texture.const_alpha == 256)) { - const QSpan *lastSpan = spans + spanCount; + const QT_FT_Span *lastSpan = spans + spanCount; bool alphaSpans = false; while (spans < lastSpan) { if (spans->coverage != 255) { @@ -3778,8 +3822,9 @@ static void spanfill_from_first(QRasterBuffer *rasterBuffer, QPixelLayout::BPP b #if defined(QT_USE_THREAD_PARALLEL_FILLS) #define QT_THREAD_PARALLEL_FILLS(function) \ const int segments = (count + 32) / 64; \ - QThreadPool *threadPool = QThreadPool::globalInstance(); \ - if (segments > 1 && threadPool && !threadPool->contains(QThread::currentThread())) { \ + QThreadPool *threadPool = QThreadPoolPrivate::qtGuiInstance(); \ + if (segments > 1 && qPixelLayouts[data->rasterBuffer->format].bpp >= QPixelLayout::BPP8 \ + && threadPool && !threadPool->contains(QThread::currentThread())) { \ QSemaphore semaphore; \ int c = 0; \ for (int i = 0; i < segments; ++i) { \ @@ -3787,7 +3832,7 @@ static void spanfill_from_first(QRasterBuffer *rasterBuffer, QPixelLayout::BPP b threadPool->start([&, c, cn]() { \ function(c, c + cn); \ semaphore.release(1); \ - }); \ + }, 1); \ c += cn; \ } \ semaphore.acquire(segments); \ @@ -3797,7 +3842,7 @@ static void spanfill_from_first(QRasterBuffer *rasterBuffer, QPixelLayout::BPP b #define QT_THREAD_PARALLEL_FILLS(function) function(0, count) #endif -static void blend_color_generic(int count, const QSpan *spans, void *userData) +static void blend_color_generic(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData *>(userData); const Operator op = getOperator(data, nullptr, 0); @@ -3831,7 +3876,7 @@ static void blend_color_generic(int count, const QSpan *spans, void *userData) QT_THREAD_PARALLEL_FILLS(function); } -static void blend_color_argb(int count, const QSpan *spans, void *userData) +static void blend_color_argb(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData *>(userData); @@ -3868,7 +3913,7 @@ static void blend_color_argb(int count, const QSpan *spans, void *userData) QT_THREAD_PARALLEL_FILLS(function); } -static void blend_color_generic_rgb64(int count, const QSpan *spans, void *userData) +static void blend_color_generic_rgb64(int count, const QT_FT_Span *spans, void *userData) { #if QT_CONFIG(raster_64bit) QSpanData *data = reinterpret_cast<QSpanData *>(userData); @@ -3912,7 +3957,7 @@ static void blend_color_generic_rgb64(int count, const QSpan *spans, void *userD #endif } -static void blend_color_generic_fp(int count, const QSpan *spans, void *userData) +static void blend_color_generic_fp(int count, const QT_FT_Span *spans, void *userData) { #if QT_CONFIG(raster_fp) QSpanData *data = reinterpret_cast<QSpanData *>(userData); @@ -3959,7 +4004,7 @@ static void blend_color_generic_fp(int count, const QSpan *spans, void *userData } template <typename T> -void handleSpans(int count, const QSpan *spans, const QSpanData *data, const Operator &op) +void handleSpans(int count, const QT_FT_Span *spans, const QSpanData *data, const Operator &op) { const int const_alpha = (data->type == QSpanData::Texture) ? data->texture.const_alpha : 256; const bool solidSource = op.mode == QPainter::CompositionMode_Source && const_alpha == 256; @@ -4131,7 +4176,7 @@ public: }; #endif -static void blend_src_generic(int count, const QSpan *spans, void *userData) +static void blend_src_generic(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData *>(userData); const Operator op = getOperator(data, nullptr, 0); @@ -4139,7 +4184,7 @@ static void blend_src_generic(int count, const QSpan *spans, void *userData) } #if QT_CONFIG(raster_64bit) -static void blend_src_generic_rgb64(int count, const QSpan *spans, void *userData) +static void blend_src_generic_rgb64(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData *>(userData); const Operator op = getOperator(data, nullptr, 0); @@ -4153,7 +4198,7 @@ static void blend_src_generic_rgb64(int count, const QSpan *spans, void *userDat #endif #if QT_CONFIG(raster_fp) -static void blend_src_generic_fp(int count, const QSpan *spans, void *userData) +static void blend_src_generic_fp(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData *>(userData); const Operator op = getOperator(data, spans, count); @@ -4166,7 +4211,7 @@ static void blend_src_generic_fp(int count, const QSpan *spans, void *userData) } #endif -static void blend_untransformed_generic(int count, const QSpan *spans, void *userData) +static void blend_untransformed_generic(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData *>(userData); @@ -4220,7 +4265,7 @@ static void blend_untransformed_generic(int count, const QSpan *spans, void *use } #if QT_CONFIG(raster_64bit) -static void blend_untransformed_generic_rgb64(int count, const QSpan *spans, void *userData) +static void blend_untransformed_generic_rgb64(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData *>(userData); @@ -4279,7 +4324,7 @@ static void blend_untransformed_generic_rgb64(int count, const QSpan *spans, voi #endif #if QT_CONFIG(raster_fp) -static void blend_untransformed_generic_fp(int count, const QSpan *spans, void *userData) +static void blend_untransformed_generic_fp(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData *>(userData); @@ -4336,7 +4381,7 @@ static void blend_untransformed_generic_fp(int count, const QSpan *spans, void * } #endif -static void blend_untransformed_argb(int count, const QSpan *spans, void *userData) +static void blend_untransformed_argb(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData *>(userData); if (data->texture.format != QImage::Format_ARGB32_Premultiplied @@ -4433,7 +4478,7 @@ static inline void blend_sourceOver_rgb16_rgb16(quint16 *Q_DECL_RESTRICT dest, } } -static void blend_untransformed_rgb565(int count, const QSpan *spans, void *userData) +static void blend_untransformed_rgb565(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData*>(userData); QPainter::CompositionMode mode = data->rasterBuffer->compositionMode; @@ -4490,7 +4535,7 @@ static void blend_untransformed_rgb565(int count, const QSpan *spans, void *user QT_THREAD_PARALLEL_FILLS(function); } -static void blend_tiled_generic(int count, const QSpan *spans, void *userData) +static void blend_tiled_generic(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData *>(userData); @@ -4543,7 +4588,7 @@ static void blend_tiled_generic(int count, const QSpan *spans, void *userData) } #if QT_CONFIG(raster_64bit) -static void blend_tiled_generic_rgb64(int count, const QSpan *spans, void *userData) +static void blend_tiled_generic_rgb64(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData *>(userData); @@ -4651,7 +4696,7 @@ static void blend_tiled_generic_rgb64(int count, const QSpan *spans, void *userD #endif #if QT_CONFIG(raster_fp) -static void blend_tiled_generic_fp(int count, const QSpan *spans, void *userData) +static void blend_tiled_generic_fp(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData *>(userData); @@ -4709,7 +4754,7 @@ static void blend_tiled_generic_fp(int count, const QSpan *spans, void *userData } #endif -static void blend_tiled_argb(int count, const QSpan *spans, void *userData) +static void blend_tiled_argb(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData *>(userData); if (data->texture.format != QImage::Format_ARGB32_Premultiplied @@ -4762,7 +4807,7 @@ static void blend_tiled_argb(int count, const QSpan *spans, void *userData) QT_THREAD_PARALLEL_FILLS(function); } -static void blend_tiled_rgb565(int count, const QSpan *spans, void *userData) +static void blend_tiled_rgb565(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData*>(userData); QPainter::CompositionMode mode = data->rasterBuffer->compositionMode; @@ -4910,15 +4955,14 @@ static const ProcessSpans processTextureSpansGenericFP[NBlendTypes] = { blend_src_generic_fp // TransformedBilinearTiled }; #endif -void qBlendTexture(int count, const QSpan *spans, void *userData) +void qBlendTexture(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData *>(userData); TextureBlendType blendType = getBlendType(data); ProcessSpans proc; switch (data->rasterBuffer->format) { case QImage::Format_Invalid: - Q_UNREACHABLE(); - return; + Q_UNREACHABLE_RETURN(); case QImage::Format_ARGB32_Premultiplied: proc = processTextureSpansARGB32PM[blendType]; break; @@ -4966,16 +5010,11 @@ void qBlendTexture(int count, const QSpan *spans, void *userData) proc(count, spans, userData); } -static void blend_vertical_gradient_argb(int count, const QSpan *spans, void *userData) +static inline bool calculate_fixed_gradient_factors(int count, const QT_FT_Span *spans, + const QSpanData *data, + const LinearGradientValues &linear, + int *pyinc, int *poff) { - QSpanData *data = reinterpret_cast<QSpanData *>(userData); - - LinearGradientValues linear; - getLinearGradientValues(&linear, data); - - CompositionFunctionSolid funcSolid = - functionForModeSolid[data->rasterBuffer->compositionMode]; - /* The logic for vertical gradient calculations is a mathematically reduced copy of that in fetchLinearGradient() - which is basically: @@ -4990,8 +5029,32 @@ static void blend_vertical_gradient_argb(int count, const QSpan *spans, void *us This has then been converted to fixed point to improve performance. */ const int gss = GRADIENT_STOPTABLE_SIZE - 1; - int yinc = int((linear.dy * data->m22 * gss) * FIXPT_SIZE); - int off = int((((linear.dy * (data->m22 * qreal(0.5) + data->dy) + linear.off) * gss) * FIXPT_SIZE)); + qreal ryinc = linear.dy * data->m22 * gss * FIXPT_SIZE; + qreal roff = (linear.dy * (data->m22 * qreal(0.5) + data->dy) + linear.off) * gss * FIXPT_SIZE; + const int limit = std::numeric_limits<int>::max() - FIXPT_SIZE; + if (count && (std::fabs(ryinc) < limit) && (std::fabs(roff) < limit) + && (std::fabs(ryinc * spans->y + roff) < limit) + && (std::fabs(ryinc * (spans + count - 1)->y + roff) < limit)) { + *pyinc = int(ryinc); + *poff = int(roff); + return true; + } + return false; +} + +static bool blend_vertical_gradient_argb(int count, const QT_FT_Span *spans, void *userData) +{ + QSpanData *data = reinterpret_cast<QSpanData *>(userData); + + LinearGradientValues linear; + getLinearGradientValues(&linear, data); + + CompositionFunctionSolid funcSolid = + functionForModeSolid[data->rasterBuffer->compositionMode]; + + int yinc(0), off(0); + if (!calculate_fixed_gradient_factors(count, spans, data, linear, &yinc, &off)) + return false; while (count--) { int y = spans->y; @@ -5004,21 +5067,20 @@ static void blend_vertical_gradient_argb(int count, const QSpan *spans, void *us funcSolid(dst, spans->len, color, spans->coverage); ++spans; } + return true; } template<ProcessSpans blend_color> -static void blend_vertical_gradient(int count, const QSpan *spans, void *userData) +static bool blend_vertical_gradient(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData *>(userData); LinearGradientValues linear; getLinearGradientValues(&linear, data); - // Based on the same logic as blend_vertical_gradient_argb. - - const int gss = GRADIENT_STOPTABLE_SIZE - 1; - int yinc = int((linear.dy * data->m22 * gss) * FIXPT_SIZE); - int off = int((((linear.dy * (data->m22 * qreal(0.5) + data->dy) + linear.off) * gss) * FIXPT_SIZE)); + int yinc(0), off(0); + if (!calculate_fixed_gradient_factors(count, spans, data, linear, &yinc, &off)) + return false; while (count--) { int y = spans->y; @@ -5031,9 +5093,10 @@ static void blend_vertical_gradient(int count, const QSpan *spans, void *userDat blend_color(1, spans, userData); ++spans; } + return true; } -void qBlendGradient(int count, const QSpan *spans, void *userData) +void qBlendGradient(int count, const QT_FT_Span *spans, void *userData) { QSpanData *data = reinterpret_cast<QSpanData *>(userData); bool isVerticalGradient = @@ -5045,8 +5108,8 @@ void qBlendGradient(int count, const QSpan *spans, void *userData) break; case QImage::Format_RGB32: case QImage::Format_ARGB32_Premultiplied: - if (isVerticalGradient) - return blend_vertical_gradient_argb(count, spans, userData); + if (isVerticalGradient && blend_vertical_gradient_argb(count, spans, userData)) + return; return blend_src_generic(count, spans, userData); #if defined(__SSE2__) || defined(__ARM_NEON__) || (Q_PROCESSOR_WORDSIZE == 8) case QImage::Format_ARGB32: @@ -5068,8 +5131,8 @@ void qBlendGradient(int count, const QSpan *spans, void *userData) case QImage::Format_RGBA32FPx4_Premultiplied: #endif #if QT_CONFIG(raster_64bit) - if (isVerticalGradient) - return blend_vertical_gradient<blend_color_generic_rgb64>(count, spans, userData); + if (isVerticalGradient && blend_vertical_gradient<blend_color_generic_rgb64>(count, spans, userData)) + return; return blend_src_generic_rgb64(count, spans, userData); #endif // QT_CONFIG(raster_64bit) #if QT_CONFIG(raster_fp) @@ -5079,13 +5142,13 @@ void qBlendGradient(int count, const QSpan *spans, void *userData) case QImage::Format_RGBX32FPx4: case QImage::Format_RGBA32FPx4: case QImage::Format_RGBA32FPx4_Premultiplied: - if (isVerticalGradient) - return blend_vertical_gradient<blend_color_generic_fp>(count, spans, userData); + if (isVerticalGradient && blend_vertical_gradient<blend_color_generic_fp>(count, spans, userData)) + return; return blend_src_generic_fp(count, spans, userData); #endif default: - if (isVerticalGradient) - return blend_vertical_gradient<blend_color_generic>(count, spans, userData); + if (isVerticalGradient && blend_vertical_gradient<blend_color_generic>(count, spans, userData)) + return; return blend_src_generic(count, spans, userData); } Q_UNREACHABLE(); @@ -5101,7 +5164,7 @@ inline void qt_bitmapblit_template(QRasterBuffer *rasterBuffer, const int destStride = rasterBuffer->stride<DST>(); if (mapWidth > 8) { - while (mapHeight--) { + while (--mapHeight >= 0) { int x0 = 0; int n = 0; for (int x = 0; x < mapWidth; x += 8) { @@ -5131,7 +5194,7 @@ inline void qt_bitmapblit_template(QRasterBuffer *rasterBuffer, map += mapStride; } } else { - while (mapHeight--) { + while (--mapHeight >= 0) { int x0 = 0; int n = 0; for (uchar s = *map; s; s <<= 1) { @@ -5315,7 +5378,7 @@ static void qt_alphamapblit_generic(QRasterBuffer *rasterBuffer, const QClipData::ClipLine &line = clip->m_clipLines[yp]; for (int i=0; i<line.count; ++i) { - const QSpan &clip = line.spans[i]; + const QT_FT_Span &clip = line.spans[i]; int start = qMax<int>(x, clip.x); int end = qMin<int>(x + mapWidth, clip.x + clip.len); @@ -5389,7 +5452,7 @@ static void qt_alphamapblit_generic(QRasterBuffer *rasterBuffer, const QClipData::ClipLine &line = clip->m_clipLines[yp]; for (int i=0; i<line.count; ++i) { - const QSpan &clip = line.spans[i]; + const QT_FT_Span &clip = line.spans[i]; int start = qMax<int>(x, clip.x); int end = qMin<int>(x + mapWidth, clip.x + clip.len); @@ -5439,7 +5502,7 @@ void qt_alphamapblit_quint16(QRasterBuffer *rasterBuffer, if (!clip) { quint16 *dest = reinterpret_cast<quint16*>(rasterBuffer->scanLine(y)) + x; const int destStride = rasterBuffer->stride<quint16>(); - while (mapHeight--) { + while (--mapHeight >= 0) { for (int i = 0; i < mapWidth; ++i) alphamapblend_quint16(map[i], dest, i, c); dest += destStride; @@ -5457,7 +5520,7 @@ void qt_alphamapblit_quint16(QRasterBuffer *rasterBuffer, quint16 *dest = reinterpret_cast<quint16*>(rasterBuffer->scanLine(yp)); for (int i=0; i<line.count; ++i) { - const QSpan &clip = line.spans[i]; + const QT_FT_Span &clip = line.spans[i]; int start = qMax<int>(x, clip.x); int end = qMin<int>(x + mapWidth, clip.x + clip.len); @@ -5493,7 +5556,7 @@ static void qt_alphamapblit_argb32(QRasterBuffer *rasterBuffer, if (!clip) { quint32 *dest = reinterpret_cast<quint32*>(rasterBuffer->scanLine(y)) + x; - while (mapHeight--) { + while (--mapHeight >= 0) { for (int i = 0; i < mapWidth; ++i) { const int coverage = map[i]; alphamapblend_argb32(dest + i, coverage, srcColor, c, colorProfile); @@ -5514,7 +5577,7 @@ static void qt_alphamapblit_argb32(QRasterBuffer *rasterBuffer, quint32 *dest = reinterpret_cast<quint32 *>(rasterBuffer->scanLine(yp)); for (int i=0; i<line.count; ++i) { - const QSpan &clip = line.spans[i]; + const QT_FT_Span &clip = line.spans[i]; int start = qMax<int>(x, clip.x); int end = qMin<int>(x + mapWidth, clip.x + clip.len); @@ -5615,7 +5678,7 @@ static inline void alphargbblend_argb32(quint32 *dst, uint coverage, const QRgba static inline void rgbBlendPixel(QRgba64 &dst, int coverage, QRgba64 slinear, const QColorTrcLut *colorProfile) { // Do a gammacorrected RGB alphablend... - const QRgba64 dlinear = colorProfile ? colorProfile->toLinear64(dst) : dst; + const QRgba64 dlinear = colorProfile ? colorProfile->toLinear(dst) : dst; QRgba64 blend = rgbBlend(dlinear, slinear, coverage); @@ -5694,7 +5757,7 @@ static void qt_alphargbblit_generic(QRasterBuffer *rasterBuffer, const QClipData::ClipLine &line = clip->m_clipLines[yp]; for (int i=0; i<line.count; ++i) { - const QSpan &clip = line.spans[i]; + const QT_FT_Span &clip = line.spans[i]; int start = qMax<int>(x, clip.x); int end = qMin<int>(x + mapWidth, clip.x + clip.len); @@ -5767,7 +5830,7 @@ static void qt_alphargbblit_generic(QRasterBuffer *rasterBuffer, const QClipData::ClipLine &line = clip->m_clipLines[yp]; for (int i=0; i<line.count; ++i) { - const QSpan &clip = line.spans[i]; + const QT_FT_Span &clip = line.spans[i]; int start = qMax<int>(x, clip.x); int end = qMin<int>(x + mapWidth, clip.x + clip.len); @@ -5811,7 +5874,7 @@ static void qt_alphargbblit_argb32(QRasterBuffer *rasterBuffer, if (!clip) { quint32 *dst = reinterpret_cast<quint32*>(rasterBuffer->scanLine(y)) + x; const int destStride = rasterBuffer->stride<quint32>(); - while (mapHeight--) { + while (--mapHeight >= 0) { for (int i = 0; i < mapWidth; ++i) { const uint coverage = src[i]; alphargbblend_argb32(dst + i, coverage, srcColor, c, colorProfile); @@ -5833,7 +5896,7 @@ static void qt_alphargbblit_argb32(QRasterBuffer *rasterBuffer, quint32 *dst = reinterpret_cast<quint32 *>(rasterBuffer->scanLine(yp)); for (int i=0; i<line.count; ++i) { - const QSpan &clip = line.spans[i]; + const QT_FT_Span &clip = line.spans[i]; int start = qMax<int>(x, clip.x); int end = qMin<int>(x + mapWidth, clip.x + clip.len); @@ -5955,7 +6018,7 @@ static void qt_rectfill_fp32x4(QRasterBuffer *rasterBuffer, // Map table for destination image format. Contains function pointers // for blends of various types unto the destination -DrawHelper qDrawHelper[QImage::NImageFormats] = +DrawHelper qDrawHelper[] = { // Format_Invalid, { nullptr, nullptr, nullptr, nullptr, nullptr }, @@ -6232,7 +6295,9 @@ DrawHelper qDrawHelper[QImage::NImageFormats] = }, }; -#if !defined(__SSE2__) +static_assert(std::size(qDrawHelper) == QImage::NImageFormats); + +#if !defined(Q_PROCESSOR_X86) void qt_memfill64(quint64 *dest, quint64 color, qsizetype count) { qt_memfill_template<quint64>(dest, color, count); @@ -6299,16 +6364,15 @@ void qt_memfill16(quint16 *dest, quint16 value, qsizetype count) qt_memfill32(reinterpret_cast<quint32*>(dest), value32, count / 2); } -#if !defined(__SSE2__) && !defined(__ARM_NEON__) && !defined(__MIPS_DSP__) +#if defined(Q_PROCESSOR_X86) +void (*qt_memfill32)(quint32 *dest, quint32 value, qsizetype count) = nullptr; +void (*qt_memfill64)(quint64 *dest, quint64 value, qsizetype count) = nullptr; +#elif !defined(__ARM_NEON__) && !defined(__MIPS_DSP__) void qt_memfill32(quint32 *dest, quint32 color, qsizetype count) { qt_memfill_template<quint32>(dest, color, count); } #endif -#ifdef __SSE2__ -decltype(qt_memfill32_sse2) *qt_memfill32 = nullptr; -decltype(qt_memfill64_sse2) *qt_memfill64 = nullptr; -#endif #ifdef QT_COMPILER_SUPPORTS_SSE4_1 template<QtPixelOrder> void QT_FASTCALL storeA2RGB30PMFromARGB32PM_sse4(uchar *dest, const uint *src, int index, int count, const QList<QRgb> *, QDitherInfo *); @@ -6321,8 +6385,11 @@ static void qInitDrawhelperFunctions() // Set up basic blend function tables. qInitBlendFunctions(); -#ifdef __SSE2__ -# ifndef __AVX2__ +#if defined(Q_PROCESSOR_X86) && !defined(__SSE2__) + qt_memfill32 = qt_memfill_template<quint32>; + qt_memfill64 = qt_memfill_template<quint64>; +#elif defined(__SSE2__) +# ifndef __haswell__ qt_memfill32 = qt_memfill32_sse2; qt_memfill64 = qt_memfill64_sse2; # endif @@ -6429,7 +6496,7 @@ static void qInitDrawhelperFunctions() extern void QT_FASTCALL storeRGBx64FromRGBA64PM_sse4(uchar *, const QRgba64 *, int, int, const QList<QRgb> *, QDitherInfo *); extern void QT_FASTCALL destStore64ARGB32_sse4(QRasterBuffer *rasterBuffer, int x, int y, const QRgba64 *buffer, int length); extern void QT_FASTCALL destStore64RGBA8888_sse4(QRasterBuffer *rasterBuffer, int x, int y, const QRgba64 *buffer, int length); -# ifndef __AVX2__ +# ifndef __haswell__ qPixelLayouts[QImage::Format_ARGB32].fetchToARGB32PM = fetchARGB32ToARGB32PM_sse4; qPixelLayouts[QImage::Format_ARGB32].convertToARGB32PM = convertARGB32ToARGB32PM_sse4; qPixelLayouts[QImage::Format_RGBA8888].fetchToARGB32PM = fetchRGBA8888ToARGB32PM_sse4; diff --git a/src/gui/painting/qdrawhelper_avx2.cpp b/src/gui/painting/qdrawhelper_avx2.cpp index 17a52402ae..34de69ecf4 100644 --- a/src/gui/painting/qdrawhelper_avx2.cpp +++ b/src/gui/painting/qdrawhelper_avx2.cpp @@ -442,14 +442,14 @@ void QT_FASTCALL comp_func_SourceOver_rgbafp_avx2(QRgbaFloat32 *dst, const QRgba _mm256_storeu_ps((float *)(dst + x), dstVector); } if (x < length) { - __m128 srcVector = _mm_load_ps((float *)(src + x)); - __m128 dstVector = _mm_load_ps((const float *)(dst + x)); + __m128 srcVector = _mm_loadu_ps((const float *)&src[x]); + __m128 dstVector = _mm_loadu_ps((const float *)&dst[x]); srcVector = _mm_mul_ps(srcVector, constAlphaVector); __m128 alphaChannel = _mm_permute_ps(srcVector, _MM_SHUFFLE(3, 3, 3, 3)); alphaChannel = _mm_sub_ps(one, alphaChannel); dstVector = _mm_mul_ps(dstVector, alphaChannel); dstVector = _mm_add_ps(dstVector, srcVector); - _mm_store_ps((float *)(dst + x), dstVector); + _mm_storeu_ps((float *)(dst + x), dstVector); } } #endif @@ -544,12 +544,12 @@ void QT_FASTCALL comp_func_Source_rgbafp_avx2(QRgbaFloat32 *dst, const QRgbaFloa _mm256_storeu_ps((float *)&dst[x], dstVector); } if (x < length) { - __m128 srcVector = _mm_load_ps((const float *)&src[x]); - __m128 dstVector = _mm_load_ps((const float *)&dst[x]); + __m128 srcVector = _mm_loadu_ps((const float *)&src[x]); + __m128 dstVector = _mm_loadu_ps((const float *)&dst[x]); srcVector = _mm_mul_ps(srcVector, constAlphaVector); dstVector = _mm_mul_ps(dstVector, oneMinusConstAlpha); dstVector = _mm_add_ps(dstVector, srcVector); - _mm_store_ps((float *)&dst[x], dstVector); + _mm_storeu_ps((float *)&dst[x], dstVector); } } } @@ -630,7 +630,7 @@ void QT_FASTCALL comp_func_solid_Source_rgbafp_avx2(QRgbaFloat32 *dst, int lengt const float a = const_alpha / 255.0f; const __m128 alphaVector = _mm_set1_ps(a); const __m128 minusAlphaVector = _mm_set1_ps(1.0f - a); - __m128 colorVector = _mm_load_ps((const float *)&color); + __m128 colorVector = _mm_loadu_ps((const float *)&color); colorVector = _mm_mul_ps(colorVector, alphaVector); const __m256 colorVector256 = _mm256_insertf128_ps(_mm256_castps128_ps256(colorVector), colorVector, 1); const __m256 minusAlphaVector256 = _mm256_set1_ps(1.0f - a); @@ -642,10 +642,10 @@ void QT_FASTCALL comp_func_solid_Source_rgbafp_avx2(QRgbaFloat32 *dst, int lengt _mm256_storeu_ps((float *)&dst[x], dstVector); } if (x < length) { - __m128 dstVector = _mm_load_ps((const float *)&dst[x]); + __m128 dstVector = _mm_loadu_ps((const float *)&dst[x]); dstVector = _mm_mul_ps(dstVector, minusAlphaVector); dstVector = _mm_add_ps(dstVector, colorVector); - _mm_store_ps((float *)&dst[x], dstVector); + _mm_storeu_ps((float *)&dst[x], dstVector); } } } @@ -657,7 +657,7 @@ void QT_FASTCALL comp_func_solid_SourceOver_rgbafp_avx2(QRgbaFloat32 *dst, int l for (int i = 0; i < length; ++i) dst[i] = color; } else { - __m128 colorVector = _mm_load_ps((const float *)&color); + __m128 colorVector = _mm_loadu_ps((const float *)&color); if (const_alpha != 255) colorVector = _mm_mul_ps(colorVector, _mm_set1_ps(const_alpha / 255.f)); __m128 minusAlphaOfColorVector = @@ -673,10 +673,10 @@ void QT_FASTCALL comp_func_solid_SourceOver_rgbafp_avx2(QRgbaFloat32 *dst, int l _mm256_storeu_ps((float *)&dst[x], dstVector); } if (x < length) { - __m128 dstVector = _mm_load_ps((const float *)&dst[x]); + __m128 dstVector = _mm_loadu_ps((const float *)&dst[x]); dstVector = _mm_mul_ps(dstVector, minusAlphaOfColorVector); dstVector = _mm_add_ps(dstVector, colorVector); - _mm_store_ps((float *)&dst[x], dstVector); + _mm_storeu_ps((float *)&dst[x], dstVector); } } } @@ -1345,13 +1345,16 @@ const QRgba64 *QT_FASTCALL fetchRGBA64ToRGBA64PM_avx2(QRgba64 *buffer, const uch vslo = _mm256_srli_epi32(vslo, 16); vshi = _mm256_srli_epi32(vshi, 16); vs256 = _mm256_packus_epi32(vslo, vshi); + vs256 = _mm256_blend_epi16(vs256, va256, 0x88); _mm256_storeu_si256((__m256i *)(buffer + i), vs256); } for (; i < count; ++i) { + const auto a = s[i].alpha(); __m128i vs = _mm_loadl_epi64((const __m128i *)(s + i)); __m128i va = _mm_shufflelo_epi16(vs, _MM_SHUFFLE(3, 3, 3, 3)); vs = multiplyAlpha65535(vs, va); _mm_storel_epi64((__m128i *)(buffer + i), vs); + buffer[i].setAlpha(a); } return buffer; } @@ -1554,7 +1557,7 @@ const QRgbaFloat32 *QT_FASTCALL fetchRGBA16FToRGBA32F_avx2(QRgbaFloat32 *buffer, __m128 vsa = _mm_permute_ps(vsf, _MM_SHUFFLE(3, 3, 3, 3)); vsf = _mm_mul_ps(vsf, vsa); vsf = _mm_insert_ps(vsf, vsa, 0x30); - _mm_store_ps((float *)(buffer + i), vsf); + _mm_storeu_ps((float *)(buffer + i), vsf); } return buffer; } @@ -1566,7 +1569,7 @@ void QT_FASTCALL storeRGBX16FFromRGBA32F_avx2(uchar *dest, const QRgbaFloat32 *s const __m128 *s = reinterpret_cast<const __m128 *>(src); const __m128 zero = _mm_set_ps(1.0f, 0.0f, 0.0f, 0.0f); for (int i = 0; i < count; ++i) { - __m128 vsf = _mm_load_ps(reinterpret_cast<const float *>(s + i)); + __m128 vsf = _mm_loadu_ps(reinterpret_cast<const float *>(s + i)); const __m128 vsa = _mm_permute_ps(vsf, _MM_SHUFFLE(3, 3, 3, 3)); const float a = _mm_cvtss_f32(vsa); if (a == 1.0f) @@ -1590,7 +1593,7 @@ void QT_FASTCALL storeRGBA16FFromRGBA32F_avx2(uchar *dest, const QRgbaFloat32 *s const __m128 *s = reinterpret_cast<const __m128 *>(src); const __m128 zero = _mm_set1_ps(0.0f); for (int i = 0; i < count; ++i) { - __m128 vsf = _mm_load_ps(reinterpret_cast<const float *>(s + i)); + __m128 vsf = _mm_loadu_ps(reinterpret_cast<const float *>(s + i)); const __m128 vsa = _mm_permute_ps(vsf, _MM_SHUFFLE(3, 3, 3, 3)); const float a = _mm_cvtss_f32(vsa); if (a == 1.0f) diff --git a/src/gui/painting/qdrawhelper_mips_dsp.cpp b/src/gui/painting/qdrawhelper_mips_dsp.cpp index af2c6598b2..86dcde2b58 100644 --- a/src/gui/painting/qdrawhelper_mips_dsp.cpp +++ b/src/gui/painting/qdrawhelper_mips_dsp.cpp @@ -95,7 +95,7 @@ void qt_blend_rgb16_on_rgb16_mips_dspr2(uchar *destPixels, int dbpl, } else { int length = w << 1; - while (h--) { + while (--h >= 0) { memcpy(destPixels, srcPixels, length); destPixels += dbpl; srcPixels += sbpl; @@ -130,7 +130,7 @@ void qt_blend_rgb16_on_rgb16_mips_dsp(uchar *destPixels, int dbpl, } else { int length = w << 1; - while (h--) { + while (--h >= 0) { memcpy(destPixels, srcPixels, length); destPixels += dbpl; srcPixels += sbpl; diff --git a/src/gui/painting/qdrawhelper_neon.cpp b/src/gui/painting/qdrawhelper_neon.cpp index 17ec693649..1fceb83710 100644 --- a/src/gui/painting/qdrawhelper_neon.cpp +++ b/src/gui/painting/qdrawhelper_neon.cpp @@ -185,7 +185,7 @@ void qt_blend_rgb16_on_argb32_neon(uchar *destPixels, int dbpl, quint8 a = (255 * const_alpha) >> 8; quint8 ia = 255 - a; - while (h--) { + while (--h >= 0) { for (int x=0; x<w; ++x) dst[x] = INTERPOLATE_PIXEL_255(qConvertRgb16To32(src[x]), a, dst[x], ia); dst += dbpl; @@ -228,7 +228,7 @@ static inline void blockBlit16(quint16 *dst, quint16 *src, int dstride, int sstr u.pointer = dst; if (u.address & 2) { - while (h--) { + while (--h >= 0) { // align dst dst[0] = src[0]; if (Width > 1) @@ -237,7 +237,7 @@ static inline void blockBlit16(quint16 *dst, quint16 *src, int dstride, int sstr src += sstride; } } else { - while (h--) { + while (--h >= 0) { scanLineBlit16<Width>(dst, src, dstride); dst += dstride; diff --git a/src/gui/painting/qdrawhelper_p.h b/src/gui/painting/qdrawhelper_p.h index cad0fa9fa3..833ddd7b16 100644 --- a/src/gui/painting/qdrawhelper_p.h +++ b/src/gui/painting/qdrawhelper_p.h @@ -29,7 +29,7 @@ #include "private/qrasterdefs_p.h" #include <private/qsimd_p.h> -#include <QtCore/qsharedpointer.h> +#include <memory> QT_BEGIN_NAMESPACE @@ -53,13 +53,6 @@ static const uint RMASK = 0x00ff0000; static const uint GMASK = 0x0000ff00; static const uint BMASK = 0x000000ff; -/******************************************************************************* - * QSpan - * - * duplicate definition of FT_Span - */ -typedef QT_FT_Span QSpan; - struct QSolidData; struct QTextureData; struct QGradientData; @@ -147,9 +140,9 @@ struct quint24 { uchar data[3]; }; -void qBlendGradient(int count, const QSpan *spans, void *userData); -void qBlendTexture(int count, const QSpan *spans, void *userData); -#ifdef __SSE2__ +void qBlendGradient(int count, const QT_FT_Span *spans, void *userData); +void qBlendTexture(int count, const QT_FT_Span *spans, void *userData); +#ifdef Q_PROCESSOR_X86 extern void (*qt_memfill64)(quint64 *dest, quint64 value, qsizetype count); extern void (*qt_memfill32)(quint32 *dest, quint32 value, qsizetype count); #else @@ -181,7 +174,6 @@ struct RadialGradientValues qreal dr; qreal sqrfr; qreal a; - qreal inv2a; bool extended; }; @@ -337,15 +329,11 @@ struct QSpanData QGradientData gradient; QTextureData texture; }; - class Pinnable { - protected: - ~Pinnable() {} - }; // QSharedPointer<const void> is not supported - QSharedPointer<const Pinnable> cachedGradient; + std::shared_ptr<const void> cachedGradient; void init(QRasterBuffer *rb, const QRasterPaintEngine *pe); - void setup(const QBrush &brush, int alpha, QPainter::CompositionMode compositionMode); + void setup(const QBrush &brush, int alpha, QPainter::CompositionMode compositionMode, bool isCosmetic); void setupMatrix(const QTransform &matrix, int bilinear); void initTexture(const QImage *image, int alpha, QTextureData::Type = QTextureData::Plain, const QRect &sourceRect = QRect()); void adjustSpanMethods(); @@ -413,12 +401,12 @@ const BlendType * QT_FASTCALL qt_fetch_radial_gradient_template(BlendType *buffe bool affine = !data->m13 && !data->m23; BlendType *end = buffer + length; + qreal inv_a = 1 / qreal(2 * op->radial.a); + if (affine) { rx -= data->gradient.radial.focal.x; ry -= data->gradient.radial.focal.y; - qreal inv_a = 1 / qreal(2 * op->radial.a); - const qreal delta_rx = data->m11; const qreal delta_ry = data->m12; @@ -463,8 +451,8 @@ const BlendType * QT_FASTCALL qt_fetch_radial_gradient_template(BlendType *buffe if (det >= 0) { qreal detSqrt = qSqrt(det); - qreal s0 = (-b - detSqrt) * op->radial.inv2a; - qreal s1 = (-b + detSqrt) * op->radial.inv2a; + qreal s0 = (-b - detSqrt) * inv_a; + qreal s1 = (-b + detSqrt) * inv_a; qreal s = qMax(s0, s1); diff --git a/src/gui/painting/qdrawhelper_sse2.cpp b/src/gui/painting/qdrawhelper_sse2.cpp index f6c4b209e4..79590534f3 100644 --- a/src/gui/painting/qdrawhelper_sse2.cpp +++ b/src/gui/painting/qdrawhelper_sse2.cpp @@ -197,7 +197,7 @@ void QT_FASTCALL comp_func_Source_sse2(uint *dst, const uint *src, int length, u } } -#ifndef __AVX2__ +#ifndef __haswell__ static Q_NEVER_INLINE void Q_DECL_VECTORCALL qt_memfillXX_aligned(void *dest, __m128i value128, quintptr bytecount) { @@ -281,7 +281,7 @@ void qt_memfill32_sse2(quint32 *dest, quint32 value, qsizetype count) qt_memfillXX_aligned(dest, _mm_set1_epi32(value), count * sizeof(quint32)); } -#endif // !__AVX2__ +#endif // !__haswell__ void QT_FASTCALL comp_func_solid_Source_sse2(uint *destPixels, int length, uint color, uint const_alpha) { @@ -361,7 +361,7 @@ void qt_bitmapblit32_sse2_base(QRasterBuffer *rasterBuffer, int x, int y, 0x04040404, 0x08080808); const __m128i maskadd2 = _mm_set_epi32(0x7f7f7f7f, 0x7e7e7e7e, 0x7c7c7c7c, 0x78787878); - while (height--) { + while (--height >= 0) { for (int x = 0; x < width; x += 8) { const quint8 s = src[x >> 3]; if (!s) @@ -380,7 +380,7 @@ void qt_bitmapblit32_sse2_base(QRasterBuffer *rasterBuffer, int x, int y, src += stride; } } else { - while (height--) { + while (--height >= 0) { const quint8 s = *src; if (s) { __m128i mask1 = _mm_set1_epi8(s); @@ -423,7 +423,7 @@ QT_WARNING_DISABLE_MSVC(4309) // truncation of constant value const __m128i maskadd = _mm_set_epi16(0x7f7f, 0x7e7e, 0x7c7c, 0x7878, 0x7070, 0x6060, 0x4040, 0x0000); - while (height--) { + while (--height >= 0) { for (int x = 0; x < width; x += 8) { const quint8 s = src[x >> 3]; if (!s) @@ -497,66 +497,42 @@ void qt_scale_image_argb32_on_argb32_sse2(uchar *destPixels, int dbpl, return qt_scale_image_argb32_on_argb32(destPixels, dbpl, srcPixels, sbpl, srch, targetRect, sourceRect, clip, const_alpha); } - qreal sx = targetRect.width() / (qreal) sourceRect.width(); - qreal sy = targetRect.height() / (qreal) sourceRect.height(); + qreal sx = sourceRect.width() / (qreal)targetRect.width(); + qreal sy = sourceRect.height() / (qreal)targetRect.height(); - int ix = 0x00010000 / sx; - int iy = 0x00010000 / sy; + const int ix = 0x00010000 * sx; + const int iy = 0x00010000 * sy; - int cx1 = clip.x(); - int cx2 = clip.x() + clip.width(); - int cy1 = clip.top(); - int cy2 = clip.y() + clip.height(); - - int tx1 = qRound(targetRect.left()); - int tx2 = qRound(targetRect.right()); - int ty1 = qRound(targetRect.top()); - int ty2 = qRound(targetRect.bottom()); - - if (tx2 < tx1) - qSwap(tx2, tx1); - if (ty2 < ty1) - qSwap(ty2, ty1); - - if (tx1 < cx1) - tx1 = cx1; - if (tx2 >= cx2) - tx2 = cx2; - - if (tx1 >= tx2) + QRect tr = targetRect.normalized().toRect(); + tr = tr.intersected(clip); + if (tr.isEmpty()) return; - - if (ty1 < cy1) - ty1 = cy1; - if (ty2 >= cy2) - ty2 = cy2; - if (ty1 >= ty2) - return; - - int h = ty2 - ty1; - int w = tx2 - tx1; + const int tx1 = tr.left(); + const int ty1 = tr.top(); + int h = tr.height(); + int w = tr.width(); quint32 basex; quint32 srcy; if (sx < 0) { - int dstx = qFloor((tx1 + qreal(0.5) - targetRect.right()) * ix) + 1; + int dstx = qFloor((tx1 + qreal(0.5) - targetRect.right()) * sx * 65536) + 1; basex = quint32(sourceRect.right() * 65536) + dstx; } else { - int dstx = qCeil((tx1 + qreal(0.5) - targetRect.left()) * ix) - 1; + int dstx = qCeil((tx1 + qreal(0.5) - targetRect.left()) * sx * 65536) - 1; basex = quint32(sourceRect.left() * 65536) + dstx; } if (sy < 0) { - int dsty = qFloor((ty1 + qreal(0.5) - targetRect.bottom()) * iy) + 1; + int dsty = qFloor((ty1 + qreal(0.5) - targetRect.bottom()) * sy * 65536) + 1; srcy = quint32(sourceRect.bottom() * 65536) + dsty; } else { - int dsty = qCeil((ty1 + qreal(0.5) - targetRect.top()) * iy) - 1; + int dsty = qCeil((ty1 + qreal(0.5) - targetRect.top()) * sy * 65536) - 1; srcy = quint32(sourceRect.top() * 65536) + dsty; } quint32 *dst = ((quint32 *) (destPixels + ty1 * dbpl)) + tx1; - const __m128i nullVector = _mm_set1_epi32(0); + const __m128i nullVector = _mm_setzero_si128(); const __m128i half = _mm_set1_epi16(0x80); const __m128i one = _mm_set1_epi16(0xff); const __m128i colorMask = _mm_set1_epi32(0x00ff00ff); @@ -582,7 +558,7 @@ void qt_scale_image_argb32_on_argb32_sse2(uchar *destPixels, int dbpl, if (xend < 0 || xend >= (int)(sbpl/sizeof(quint32))) --w; - while (h--) { + while (--h >= 0) { const uint *src = (const quint32 *) (srcPixels + (srcy >> 16) * sbpl); int srcx = basex; int x = 0; @@ -595,13 +571,14 @@ void qt_scale_image_argb32_on_argb32_sse2(uchar *destPixels, int dbpl, __m128i srcxVector = _mm_set_epi32(srcx, srcx + ix, srcx + ix + ix, srcx + ix + ix + ix); - for (; x<w - 3; x += 4) { - union Vect_buffer { __m128i vect; quint32 i[4]; }; - Vect_buffer addr; - addr.vect = _mm_srli_epi32(srcxVector, 16); + for (; x < (w - 3); x += 4) { + const int idx0 = _mm_extract_epi16(srcxVector, 1); + const int idx1 = _mm_extract_epi16(srcxVector, 3); + const int idx2 = _mm_extract_epi16(srcxVector, 5); + const int idx3 = _mm_extract_epi16(srcxVector, 7); srcxVector = _mm_add_epi32(srcxVector, ixVector); - const __m128i srcVector = _mm_set_epi32(src[addr.i[0]], src[addr.i[1]], src[addr.i[2]], src[addr.i[3]]); + const __m128i srcVector = _mm_set_epi32(src[idx0], src[idx1], src[idx2], src[idx3]); BLEND_SOURCE_OVER_ARGB32_SSE2_helper(dst, srcVector, nullVector, half, one, colorMask, alphaMask); } diff --git a/src/gui/painting/qdrawhelper_sse4.cpp b/src/gui/painting/qdrawhelper_sse4.cpp index 7b9481eb3a..a7b4e6ba76 100644 --- a/src/gui/painting/qdrawhelper_sse4.cpp +++ b/src/gui/painting/qdrawhelper_sse4.cpp @@ -10,7 +10,7 @@ QT_BEGIN_NAMESPACE -#ifndef __AVX2__ +#ifndef __haswell__ template<bool RGBA> static void convertARGBToARGB32PM_sse4(uint *buffer, const uint *src, int count) { @@ -106,7 +106,7 @@ static void convertARGBToRGBA64PM_sse4(QRgba64 *buffer, const uint *src, int cou buffer[i] = QRgba64::fromArgb32(s).premultiplied(); } } -#endif // __AVX2__ +#endif // __haswell__ static inline __m128 Q_DECL_VECTORCALL reciprocal_mul_ps(__m128 a, float mul) { @@ -375,7 +375,7 @@ static inline void convertRGBA64FromRGBA64PM_sse4(QRgba64 *buffer, const QRgba64 } } -#ifndef __AVX2__ +#ifndef __haswell__ void QT_FASTCALL convertARGB32ToARGB32PM_sse4(uint *buffer, int count, const QList<QRgb> *) { convertARGBToARGB32PM_sse4<false>(buffer, buffer, count); @@ -427,7 +427,7 @@ const QRgba64 *QT_FASTCALL fetchRGBA8888ToRGBA64PM_sse4(QRgba64 *buffer, const u convertARGBToRGBA64PM_sse4<true>(buffer, reinterpret_cast<const uint *>(src) + index, count); return buffer; } -#endif // __AVX2__ +#endif // __haswell__ void QT_FASTCALL storeRGB32FromARGB32PM_sse4(uchar *dest, const uint *src, int index, int count, const QList<QRgb> *, QDitherInfo *) diff --git a/src/gui/painting/qfixed_p.h b/src/gui/painting/qfixed_p.h index da69f901cd..c0a13d057f 100644 --- a/src/gui/painting/qfixed_p.h +++ b/src/gui/painting/qfixed_p.h @@ -18,6 +18,7 @@ #include <QtGui/private/qtguiglobal_p.h> #include "QtCore/qdebug.h" #include "QtCore/qpoint.h" +#include "QtCore/qnumeric.h" #include "QtCore/qsize.h" QT_BEGIN_NAMESPACE @@ -29,8 +30,7 @@ public: constexpr QFixed() : val(0) {} constexpr QFixed(int i) : val(i * 64) {} constexpr QFixed(long i) : val(i * 64) {} - QFixed &operator=(int i) { val = i * 64; return *this; } - QFixed &operator=(long i) { val = i * 64; return *this; } + constexpr QFixed(long long i) : val(i * 64) {} constexpr static QFixed fromReal(qreal r) { return fromFixed((int)(r*qreal(64))); } constexpr static QFixed fromFixed(int fixed) { return QFixed(fixed,0); } // uses private ctor @@ -48,28 +48,33 @@ public: constexpr inline QFixed operator+(int i) const { return fromFixed(val + i * 64); } constexpr inline QFixed operator+(uint i) const { return fromFixed((val + (i<<6))); } - constexpr inline QFixed operator+(const QFixed &other) const { return fromFixed((val + other.val)); } + constexpr inline QFixed operator+(QFixed other) const { return fromFixed((val + other.val)); } inline QFixed &operator+=(int i) { val += i * 64; return *this; } inline QFixed &operator+=(uint i) { val += (i<<6); return *this; } - inline QFixed &operator+=(const QFixed &other) { val += other.val; return *this; } + inline QFixed &operator+=(QFixed other) { val += other.val; return *this; } constexpr inline QFixed operator-(int i) const { return fromFixed(val - i * 64); } constexpr inline QFixed operator-(uint i) const { return fromFixed((val - (i<<6))); } - constexpr inline QFixed operator-(const QFixed &other) const { return fromFixed((val - other.val)); } + constexpr inline QFixed operator-(QFixed other) const { return fromFixed((val - other.val)); } inline QFixed &operator-=(int i) { val -= i * 64; return *this; } inline QFixed &operator-=(uint i) { val -= (i<<6); return *this; } - inline QFixed &operator-=(const QFixed &other) { val -= other.val; return *this; } + inline QFixed &operator-=(QFixed other) { val -= other.val; return *this; } constexpr inline QFixed operator-() const { return fromFixed(-val); } - constexpr inline bool operator==(const QFixed &other) const { return val == other.val; } - constexpr inline bool operator!=(const QFixed &other) const { return val != other.val; } - constexpr inline bool operator<(const QFixed &other) const { return val < other.val; } - constexpr inline bool operator>(const QFixed &other) const { return val > other.val; } - constexpr inline bool operator<=(const QFixed &other) const { return val <= other.val; } - constexpr inline bool operator>=(const QFixed &other) const { return val >= other.val; } +#define REL_OP(op) \ + friend constexpr bool operator op(QFixed lhs, QFixed rhs) noexcept \ + { return lhs.val op rhs.val; } + REL_OP(==) + REL_OP(!=) + REL_OP(< ) + REL_OP(> ) + REL_OP(<=) + REL_OP(>=) +#undef REL_OP + constexpr inline bool operator!() const { return !val; } inline QFixed &operator/=(int x) { val /= x; return *this; } - inline QFixed &operator/=(const QFixed &o) { + inline QFixed &operator/=(QFixed o) { if (o.val == 0) { val = 0x7FFFFFFFL; } else { @@ -90,7 +95,7 @@ public: inline QFixed operator>>(int d) const { QFixed f = *this; f.val >>= d; return f; } inline QFixed &operator*=(int i) { val *= i; return *this; } inline QFixed &operator*=(uint i) { val *= i; return *this; } - inline QFixed &operator*=(const QFixed &o) { + inline QFixed &operator*=(QFixed o) { bool neg = false; qint64 a = val; qint64 b = o.val; @@ -103,11 +108,10 @@ public: } constexpr inline QFixed operator*(int i) const { return fromFixed(val * i); } constexpr inline QFixed operator*(uint i) const { return fromFixed(val * i); } - inline QFixed operator*(const QFixed &o) const { QFixed f = *this; return (f *= o); } + inline QFixed operator*(QFixed o) const { QFixed f = *this; return (f *= o); } private: constexpr QFixed(qreal i) : val((int)(i*qreal(64))) {} - QFixed &operator=(qreal i) { val = (int)(i*qreal(64)); return *this; } constexpr inline QFixed operator+(qreal i) const { return fromFixed((val + (int)(i*qreal(64)))); } inline QFixed &operator+=(qreal i) { val += (int)(i*64); return *this; } constexpr inline QFixed operator-(qreal i) const { return fromFixed((val - (int)(i*qreal(64)))); } @@ -122,32 +126,35 @@ Q_DECLARE_TYPEINFO(QFixed, Q_PRIMITIVE_TYPE); #define QFIXED_MAX (INT_MAX/256) -constexpr inline int qRound(const QFixed &f) { return f.toInt(); } -constexpr inline int qFloor(const QFixed &f) { return f.floor().truncate(); } - -constexpr inline QFixed operator*(int i, const QFixed &d) { return d*i; } -constexpr inline QFixed operator+(int i, const QFixed &d) { return d+i; } -constexpr inline QFixed operator-(int i, const QFixed &d) { return -(d-i); } -constexpr inline QFixed operator*(uint i, const QFixed &d) { return d*i; } -constexpr inline QFixed operator+(uint i, const QFixed &d) { return d+i; } -constexpr inline QFixed operator-(uint i, const QFixed &d) { return -(d-i); } -// constexpr inline QFixed operator*(qreal d, const QFixed &d2) { return d2*d; } - -constexpr inline bool operator==(const QFixed &f, int i) { return f.value() == i * 64; } -constexpr inline bool operator==(int i, const QFixed &f) { return f.value() == i * 64; } -constexpr inline bool operator!=(const QFixed &f, int i) { return f.value() != i * 64; } -constexpr inline bool operator!=(int i, const QFixed &f) { return f.value() != i * 64; } -constexpr inline bool operator<=(const QFixed &f, int i) { return f.value() <= i * 64; } -constexpr inline bool operator<=(int i, const QFixed &f) { return i * 64 <= f.value(); } -constexpr inline bool operator>=(const QFixed &f, int i) { return f.value() >= i * 64; } -constexpr inline bool operator>=(int i, const QFixed &f) { return i * 64 >= f.value(); } -constexpr inline bool operator<(const QFixed &f, int i) { return f.value() < i * 64; } -constexpr inline bool operator<(int i, const QFixed &f) { return i * 64 < f.value(); } -constexpr inline bool operator>(const QFixed &f, int i) { return f.value() > i * 64; } -constexpr inline bool operator>(int i, const QFixed &f) { return i * 64 > f.value(); } +constexpr inline int qRound(QFixed f) { return f.toInt(); } +constexpr inline int qFloor(QFixed f) { return f.floor().truncate(); } + +constexpr inline QFixed operator*(int i, QFixed d) { return d*i; } +constexpr inline QFixed operator+(int i, QFixed d) { return d+i; } +constexpr inline QFixed operator-(int i, QFixed d) { return -(d-i); } +constexpr inline QFixed operator*(uint i, QFixed d) { return d*i; } +constexpr inline QFixed operator+(uint i, QFixed d) { return d+i; } +constexpr inline QFixed operator-(uint i, QFixed d) { return -(d-i); } +// constexpr inline QFixed operator*(qreal d, QFixed d2) { return d2*d; } + +inline bool qAddOverflow(QFixed v1, QFixed v2, QFixed *r) +{ + int val; + bool result = qAddOverflow(v1.value(), v2.value(), &val); + r->setValue(val); + return result; +} + +inline bool qMulOverflow(QFixed v1, QFixed v2, QFixed *r) +{ + int val; + bool result = qMulOverflow(v1.value(), v2.value(), &val); + r->setValue(val); + return result; +} #ifndef QT_NO_DEBUG_STREAM -inline QDebug &operator<<(QDebug &dbg, const QFixed &f) +inline QDebug &operator<<(QDebug &dbg, QFixed f) { return dbg << f.toReal(); } #endif @@ -155,7 +162,7 @@ struct QFixedPoint { QFixed x; QFixed y; constexpr inline QFixedPoint() {} - constexpr inline QFixedPoint(const QFixed &_x, const QFixed &_y) : x(_x), y(_y) {} + constexpr inline QFixedPoint(QFixed _x, QFixed _y) : x(_x), y(_y) {} constexpr QPointF toPointF() const { return QPointF(x.toReal(), y.toReal()); } constexpr static QFixedPoint fromPointF(const QPointF &p) { return QFixedPoint(QFixed::fromReal(p.x()), QFixed::fromReal(p.y())); diff --git a/src/gui/painting/qicc.cpp b/src/gui/painting/qicc.cpp index 9d95c80bf8..c01fa433ea 100644 --- a/src/gui/painting/qicc.cpp +++ b/src/gui/painting/qicc.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2020 The Qt Company Ltd. +// Copyright (C) 2024 The Qt Company Ltd. // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only #include "qicc_p.h" @@ -12,6 +12,8 @@ #include <qloggingcategory.h> #include <qstring.h> +#include "qcolorclut_p.h" +#include "qcolormatrix_p.h" #include "qcolorspace_p.h" #include "qcolortrc_p.h" @@ -20,6 +22,8 @@ QT_BEGIN_NAMESPACE Q_LOGGING_CATEGORY(lcIcc, "qt.gui.icc", QtWarningMsg) +namespace QIcc { + struct ICCProfileHeader { quint32_be profileSize; @@ -58,18 +62,23 @@ constexpr quint32 IccTag(uchar a, uchar b, uchar c, uchar d) enum class ColorSpaceType : quint32 { Rgb = IccTag('R', 'G', 'B', ' '), Gray = IccTag('G', 'R', 'A', 'Y'), + Cmyk = IccTag('C', 'M', 'Y', 'K'), }; enum class ProfileClass : quint32 { - Input = IccTag('s', 'c', 'r', 'n'), + Input = IccTag('s', 'c', 'n', 'r'), Display = IccTag('m', 'n', 't', 'r'), - // Not supported: Output = IccTag('p', 'r', 't', 'r'), ColorSpace = IccTag('s', 'p', 'a', 'c'), + // Not supported: + DeviceLink = IccTag('l', 'i', 'n', 'k'), + Abstract = IccTag('a', 'b', 's', 't'), + NamedColor = IccTag('n', 'm', 'c', 'l'), }; enum class Tag : quint32 { acsp = IccTag('a', 'c', 's', 'p'), + Lab_ = IccTag('L', 'a', 'b', ' '), RGB_ = IccTag('R', 'G', 'B', ' '), XYZ_ = IccTag('X', 'Y', 'Z', ' '), rXYZ = IccTag('r', 'X', 'Y', 'Z'), @@ -81,8 +90,18 @@ enum class Tag : quint32 { kTRC = IccTag('k', 'T', 'R', 'C'), A2B0 = IccTag('A', '2', 'B', '0'), A2B1 = IccTag('A', '2', 'B', '1'), + A2B2 = IccTag('A', '2', 'B', '2'), B2A0 = IccTag('B', '2', 'A', '0'), B2A1 = IccTag('B', '2', 'A', '1'), + B2A2 = IccTag('B', '2', 'A', '2'), + B2D0 = IccTag('B', '2', 'D', '0'), + B2D1 = IccTag('B', '2', 'D', '1'), + B2D2 = IccTag('B', '2', 'D', '2'), + B2D3 = IccTag('B', '2', 'D', '3'), + D2B0 = IccTag('D', '2', 'B', '0'), + D2B1 = IccTag('D', '2', 'B', '1'), + D2B2 = IccTag('D', '2', 'B', '2'), + D2B3 = IccTag('D', '2', 'B', '3'), desc = IccTag('d', 'e', 's', 'c'), text = IccTag('t', 'e', 'x', 't'), cprt = IccTag('c', 'p', 'r', 't'), @@ -93,9 +112,11 @@ enum class Tag : quint32 { mft1 = IccTag('m', 'f', 't', '1'), mft2 = IccTag('m', 'f', 't', '2'), mluc = IccTag('m', 'l', 'u', 'c'), + mpet = IccTag('m', 'p', 'e', 't'), mAB_ = IccTag('m', 'A', 'B', ' '), mBA_ = IccTag('m', 'B', 'A', ' '), chad = IccTag('c', 'h', 'a', 'd'), + gamt = IccTag('g', 'a', 'm', 't'), sf32 = IccTag('s', 'f', '3', '2'), // Apple extensions for ICCv2: @@ -104,7 +125,9 @@ enum class Tag : quint32 { aabg = IccTag('a', 'a', 'b', 'g'), }; -inline size_t qHash(const Tag &key, size_t seed = 0) +} // namespace QIcc + +inline size_t qHash(const QIcc::Tag &key, size_t seed = 0) { return qHash(quint32(key), seed); } @@ -159,6 +182,46 @@ struct MlucTagData : GenericTagData { MlucTagRecord records[1]; }; +struct Lut8TagData : GenericTagData { + quint8 inputChannels; + quint8 outputChannels; + quint8 clutGridPoints; + quint8 padding; + qint32_be e1; + qint32_be e2; + qint32_be e3; + qint32_be e4; + qint32_be e5; + qint32_be e6; + qint32_be e7; + qint32_be e8; + qint32_be e9; + // followed by parameter values: quint8[inputChannels * 256]; + // followed by parameter values: quint8[outputChannels * clutGridPoints^inputChannels]; + // followed by parameter values: quint8[outputChannels * 256]; +}; + +struct Lut16TagData : GenericTagData { + quint8 inputChannels; + quint8 outputChannels; + quint8 clutGridPoints; + quint8 padding; + qint32_be e1; + qint32_be e2; + qint32_be e3; + qint32_be e4; + qint32_be e5; + qint32_be e6; + qint32_be e7; + qint32_be e8; + qint32_be e9; + quint16_be inputTableEntries; + quint16_be outputTableEntries; + // followed by parameter values: quint16_be[inputChannels * inputTableEntries]; + // followed by parameter values: quint16_be[outputChannels * clutGridPoints^inputChannels]; + // followed by parameter values: quint16_be[outputChannels * outputTableEntries]; +}; + // For both mAB and mBA struct mABTagData : GenericTagData { quint8 inputChannels; @@ -169,10 +232,34 @@ struct mABTagData : GenericTagData { quint32_be mCurvesOffset; quint32_be clutOffset; quint32_be aCurvesOffset; + // followed by embedded data for the offsets above +}; + +struct mpetTagData : GenericTagData { + quint16_be inputChannels; + quint16_be outputChannels; + quint32_be processingElements; + // element offset table + // element data }; struct Sf32TagData : GenericTagData { - quint32_be value[1]; + quint32_be value[9]; +}; + +struct MatrixElement { + qint32_be e0; + qint32_be e1; + qint32_be e2; + qint32_be e3; + qint32_be e4; + qint32_be e5; + qint32_be e6; + qint32_be e7; + qint32_be e8; + qint32_be e9; + qint32_be e10; + qint32_be e11; }; static int toFixedS1516(float x) @@ -204,19 +291,19 @@ static bool isValidIccProfile(const ICCProfileHeader &header) if (header.profileClass != uint(ProfileClass::Input) && header.profileClass != uint(ProfileClass::Display) - && (header.profileClass != uint(ProfileClass::Output) - || header.inputColorSpace != uint(ColorSpaceType::Gray))) { + && header.profileClass != uint(ProfileClass::Output) + && header.profileClass != uint(ProfileClass::ColorSpace)) { qCInfo(lcIcc, "Unsupported ICC profile class 0x%x", quint32(header.profileClass)); return false; } if (header.inputColorSpace != uint(ColorSpaceType::Rgb) - && header.inputColorSpace != uint(ColorSpaceType::Gray)) { + && header.inputColorSpace != uint(ColorSpaceType::Gray) + && header.inputColorSpace != uint(ColorSpaceType::Cmyk)) { qCInfo(lcIcc, "Unsupported ICC input color space 0x%x", quint32(header.inputColorSpace)); return false; } - if (header.pcs != 0x58595a20 /* 'XYZ '*/) { - // ### support PCSLAB - qCInfo(lcIcc, "Unsupported ICC profile connection space 0x%x", quint32(header.pcs)); + if (header.pcs != uint(Tag::XYZ_) && header.pcs != uint(Tag::Lab_)) { + qCInfo(lcIcc, "Invalid ICC profile connection space 0x%x", quint32(header.pcs)); return false; } @@ -234,7 +321,7 @@ static bool isValidIccProfile(const ICCProfileHeader &header) static int writeColorTrc(QDataStream &stream, const QColorTrc &trc) { - if (trc.isLinear()) { + if (trc.isIdentity()) { stream << uint(Tag::curv) << uint(0); stream << uint(0); return 12; @@ -274,6 +361,10 @@ static int writeColorTrc(QDataStream &stream, const QColorTrc &trc) stream << ushort(trc.m_table.m_table8[i] * 257U); } } + if (trc.m_table.m_tableSize & 1) { + stream << ushort(0); + return 12 + 2 * trc.m_table.m_tableSize + 2; + } return 12 + 2 * trc.m_table.m_tableSize; } @@ -283,10 +374,21 @@ QByteArray toIccProfile(const QColorSpace &space) return QByteArray(); const QColorSpacePrivate *spaceDPtr = QColorSpacePrivate::get(space); + // This should catch anything not three component matrix based as we can only get that from parsed ICC + if (!spaceDPtr->iccProfile.isEmpty()) + return spaceDPtr->iccProfile; + Q_ASSERT(spaceDPtr->isThreeComponentMatrix()); + + int fixedLengthTagCount = 5; + bool writeChad = false; + if (!spaceDPtr->whitePoint.isNull() && spaceDPtr->whitePoint != QColorVector::D50()) { + writeChad = true; + fixedLengthTagCount++; + } - constexpr int tagCount = 9; - constexpr uint profileDataOffset = 128 + 4 + 12 * tagCount; - constexpr uint variableTagTableOffsets = 128 + 4 + 12 * 5; + const int tagCount = fixedLengthTagCount + 4; + const uint profileDataOffset = 128 + 4 + 12 * tagCount; + const uint variableTagTableOffsets = 128 + 4 + 12 * fixedLengthTagCount; uint currentOffset = 0; uint rTrcOffset, gTrcOffset, bTrcOffset; uint rTrcSize, gTrcSize, bTrcSize; @@ -299,10 +401,10 @@ QByteArray toIccProfile(const QColorSpace &space) // Profile header: stream << uint(0); // Size, we will update this later stream << uint(0); - stream << uint(0x02400000); // Version 2.4 (note we use 'para' from version 4) + stream << uint(0x04400000); // Version 4.4 stream << uint(ProfileClass::Display); stream << uint(Tag::RGB_); - stream << uint(Tag::XYZ_); + stream << (spaceDPtr->isPcsLab ? uint(Tag::Lab_) : uint(Tag::XYZ_)); stream << uint(0) << uint(0) << uint(0); stream << uint(Tag::acsp); stream << uint(0) << uint(0) << uint(0); @@ -316,19 +418,23 @@ QByteArray toIccProfile(const QColorSpace &space) stream << uint(0) << uint(0) << uint(0) << uint(0) << uint(0) << uint(0) << uint(0); // Tag table: + currentOffset = profileDataOffset; stream << uint(tagCount); stream << uint(Tag::rXYZ) << uint(profileDataOffset + 00) << uint(20); stream << uint(Tag::gXYZ) << uint(profileDataOffset + 20) << uint(20); stream << uint(Tag::bXYZ) << uint(profileDataOffset + 40) << uint(20); stream << uint(Tag::wtpt) << uint(profileDataOffset + 60) << uint(20); - stream << uint(Tag::cprt) << uint(profileDataOffset + 80) << uint(12); + stream << uint(Tag::cprt) << uint(profileDataOffset + 80) << uint(34); + currentOffset += 20 + 20 + 20 + 20 + 34 + 2; + if (writeChad) { + stream << uint(Tag::chad) << uint(currentOffset) << uint(44); + currentOffset += 44; + } // From here the offset and size will be updated later: stream << uint(Tag::rTRC) << uint(0) << uint(0); stream << uint(Tag::gTRC) << uint(0) << uint(0); stream << uint(Tag::bTRC) << uint(0) << uint(0); stream << uint(Tag::desc) << uint(0) << uint(0); - // TODO: consider adding 'chad' tag (required in ICC >=4 when we have non-D50 whitepoint) - currentOffset = profileDataOffset; // Tag data: stream << uint(Tag::XYZ_) << uint(0); @@ -347,9 +453,25 @@ QByteArray toIccProfile(const QColorSpace &space) stream << toFixedS1516(spaceDPtr->whitePoint.x); stream << toFixedS1516(spaceDPtr->whitePoint.y); stream << toFixedS1516(spaceDPtr->whitePoint.z); - stream << uint(Tag::text) << uint(0); - stream << uint(IccTag('N', '/', 'A', '\0')); - currentOffset += 92; + stream << uint(Tag::mluc) << uint(0); + stream << uint(1) << uint(12); + stream << uchar('e') << uchar('n') << uchar('U') << uchar('S'); + stream << uint(6) << uint(28); + stream << ushort('N') << ushort('/') << ushort('A'); + stream << ushort(0); // 4-byte alignment + if (writeChad) { + QColorMatrix chad = QColorMatrix::chromaticAdaptation(spaceDPtr->whitePoint); + stream << uint(Tag::sf32) << uint(0); + stream << toFixedS1516(chad.r.x); + stream << toFixedS1516(chad.g.x); + stream << toFixedS1516(chad.b.x); + stream << toFixedS1516(chad.r.y); + stream << toFixedS1516(chad.g.y); + stream << toFixedS1516(chad.b.y); + stream << toFixedS1516(chad.r.z); + stream << toFixedS1516(chad.g.z); + stream << toFixedS1516(chad.b.z); + } // From now on the data is variable sized: rTrcOffset = currentOffset; @@ -372,16 +494,20 @@ QByteArray toIccProfile(const QColorSpace &space) currentOffset += bTrcSize; } + // Writing description descOffset = currentOffset; - QByteArray description = space.description().toUtf8(); - stream << uint(Tag::desc) << uint(0); - stream << uint(description.size() + 1); - stream.writeRawData(description.constData(), description.size() + 1); - stream << uint(0) << uint(0); - stream << ushort(0) << uchar(0); - QByteArray macdesc(67, '\0'); - stream.writeRawData(macdesc.constData(), 67); - descSize = 90 + description.size() + 1; + const QString description = space.description(); + stream << uint(Tag::mluc) << uint(0); + stream << uint(1) << uint(12); + stream << uchar('e') << uchar('n') << uchar('U') << uchar('S'); + stream << uint(description.size() * 2) << uint(28); + for (QChar ch : description) + stream << ushort(ch.unicode()); + descSize = 28 + description.size() * 2; + if (description.size() & 1) { + stream << ushort(0); + currentOffset += 2; + } currentOffset += descSize; buffer.close(); @@ -412,7 +538,7 @@ struct TagEntry { quint32 size; }; -bool parseXyzData(const QByteArray &data, const TagEntry &tagEntry, QColorVector &colorVector) +static bool parseXyzData(const QByteArray &data, const TagEntry &tagEntry, QColorVector &colorVector) { if (tagEntry.size < sizeof(XYZTagData)) { qCWarning(lcIcc) << "Undersized XYZ tag"; @@ -431,23 +557,22 @@ bool parseXyzData(const QByteArray &data, const TagEntry &tagEntry, QColorVector return true; } -bool parseTRC(const QByteArray &data, const TagEntry &tagEntry, QColorTrc &gamma) +static quint32 parseTRC(const QByteArrayView &tagData, QColorTrc &gamma, QColorTransferTable::Type type = QColorTransferTable::TwoWay) { - const GenericTagData trcData = qFromUnaligned<GenericTagData>(data.constData() - + tagEntry.offset); + const GenericTagData trcData = qFromUnaligned<GenericTagData>(tagData.constData()); if (trcData.type == quint32(Tag::curv)) { Q_STATIC_ASSERT(sizeof(CurvTagData) == 12); - const CurvTagData curv = qFromUnaligned<CurvTagData>(data.constData() + tagEntry.offset); + const CurvTagData curv = qFromUnaligned<CurvTagData>(tagData.constData()); if (curv.valueCount > (1 << 16)) - return false; - if (tagEntry.size - 12 < 2 * curv.valueCount) - return false; - const auto valueOffset = tagEntry.offset + sizeof(CurvTagData); + return 0; + if (tagData.size() < qsizetype(12 + 2 * curv.valueCount)) + return 0; + const auto valueOffset = sizeof(CurvTagData); if (curv.valueCount == 0) { gamma.m_type = QColorTrc::Type::Function; gamma.m_fun = QColorTransferFunction(); // Linear } else if (curv.valueCount == 1) { - const quint16 v = qFromBigEndian<quint16>(data.constData() + valueOffset); + const quint16 v = qFromBigEndian<quint16>(tagData.constData() + valueOffset); gamma.m_type = QColorTrc::Type::Function; gamma.m_fun = QColorTransferFunction::fromGamma(v * (1.0f / 256.0f)); } else { @@ -455,12 +580,12 @@ bool parseTRC(const QByteArray &data, const TagEntry &tagEntry, QColorTrc &gamma tabl.resize(curv.valueCount); static_assert(sizeof(GenericTagData) == 2 * sizeof(quint32_be), "GenericTagData has padding. The following code is a subject to UB."); - qFromBigEndian<quint16>(data.constData() + valueOffset, curv.valueCount, tabl.data()); - QColorTransferTable table = QColorTransferTable(curv.valueCount, std::move(tabl)); + qFromBigEndian<quint16>(tagData.constData() + valueOffset, curv.valueCount, tabl.data()); + QColorTransferTable table(curv.valueCount, tabl, type); QColorTransferFunction curve; if (!table.checkValidity()) { qCWarning(lcIcc) << "Invalid curv table"; - return false; + return 0; } else if (!table.asColorTransferFunction(&curve)) { gamma.m_type = QColorTrc::Type::Table; gamma.m_table = table; @@ -470,43 +595,43 @@ bool parseTRC(const QByteArray &data, const TagEntry &tagEntry, QColorTrc &gamma gamma.m_fun = curve; } } - return true; + return 12 + 2 * curv.valueCount; } if (trcData.type == quint32(Tag::para)) { Q_STATIC_ASSERT(sizeof(ParaTagData) == 12); - const ParaTagData para = qFromUnaligned<ParaTagData>(data.constData() + tagEntry.offset); - const auto parametersOffset = tagEntry.offset + sizeof(ParaTagData); + const ParaTagData para = qFromUnaligned<ParaTagData>(tagData.constData()); + const auto parametersOffset = sizeof(ParaTagData); quint32 parameters[7]; switch (para.curveType) { case 0: { - if (tagEntry.size < sizeof(ParaTagData) + 1 * 4) - return false; - qFromBigEndian<quint32>(data.constData() + parametersOffset, 1, parameters); + if (tagData.size() < 12 + 1 * 4) + return 0; + qFromBigEndian<quint32>(tagData.constData() + parametersOffset, 1, parameters); float g = fromFixedS1516(parameters[0]); gamma.m_type = QColorTrc::Type::Function; gamma.m_fun = QColorTransferFunction::fromGamma(g); - break; + return 12 + 1 * 4; } case 1: { - if (tagEntry.size < sizeof(ParaTagData) + 3 * 4) - return false; - qFromBigEndian<quint32>(data.constData() + parametersOffset, 3, parameters); + if (tagData.size() < 12 + 3 * 4) + return 0; + qFromBigEndian<quint32>(tagData.constData() + parametersOffset, 3, parameters); if (parameters[1] == 0) - return false; + return 0; float g = fromFixedS1516(parameters[0]); float a = fromFixedS1516(parameters[1]); float b = fromFixedS1516(parameters[2]); float d = -b / a; gamma.m_type = QColorTrc::Type::Function; gamma.m_fun = QColorTransferFunction(a, b, 0.0f, d, 0.0f, 0.0f, g); - break; + return 12 + 3 * 4; } case 2: { - if (tagEntry.size < sizeof(ParaTagData) + 4 * 4) - return false; - qFromBigEndian<quint32>(data.constData() + parametersOffset, 4, parameters); + if (tagData.size() < 12 + 4 * 4) + return 0; + qFromBigEndian<quint32>(tagData.constData() + parametersOffset, 4, parameters); if (parameters[1] == 0) - return false; + return 0; float g = fromFixedS1516(parameters[0]); float a = fromFixedS1516(parameters[1]); float b = fromFixedS1516(parameters[2]); @@ -514,12 +639,12 @@ bool parseTRC(const QByteArray &data, const TagEntry &tagEntry, QColorTrc &gamma float d = -b / a; gamma.m_type = QColorTrc::Type::Function; gamma.m_fun = QColorTransferFunction(a, b, 0.0f, d, c, c, g); - break; + return 12 + 4 * 4; } case 3: { - if (tagEntry.size < sizeof(ParaTagData) + 5 * 4) - return false; - qFromBigEndian<quint32>(data.constData() + parametersOffset, 5, parameters); + if (tagData.size() < 12 + 5 * 4) + return 0; + qFromBigEndian<quint32>(tagData.constData() + parametersOffset, 5, parameters); float g = fromFixedS1516(parameters[0]); float a = fromFixedS1516(parameters[1]); float b = fromFixedS1516(parameters[2]); @@ -527,12 +652,12 @@ bool parseTRC(const QByteArray &data, const TagEntry &tagEntry, QColorTrc &gamma float d = fromFixedS1516(parameters[4]); gamma.m_type = QColorTrc::Type::Function; gamma.m_fun = QColorTransferFunction(a, b, c, d, 0.0f, 0.0f, g); - break; + return 12 + 5 * 4; } case 4: { - if (tagEntry.size < sizeof(ParaTagData) + 7 * 4) - return false; - qFromBigEndian<quint32>(data.constData() + parametersOffset, 7, parameters); + if (tagData.size() < 12 + 7 * 4) + return 0; + qFromBigEndian<quint32>(tagData.constData() + parametersOffset, 7, parameters); float g = fromFixedS1516(parameters[0]); float a = fromFixedS1516(parameters[1]); float b = fromFixedS1516(parameters[2]); @@ -542,19 +667,401 @@ bool parseTRC(const QByteArray &data, const TagEntry &tagEntry, QColorTrc &gamma float f = fromFixedS1516(parameters[6]); gamma.m_type = QColorTrc::Type::Function; gamma.m_fun = QColorTransferFunction(a, b, c, d, e, f, g); - break; + return 12 + 7 * 4; } default: qCWarning(lcIcc) << "Unknown para type" << uint(para.curveType); + return 0; + } + return true; + } + qCWarning(lcIcc) << "Invalid TRC data type" << Qt::hex << trcData.type; + return 0; +} + +template<typename T> +static void parseCLUT(const T *tableData, const float f, QColorCLUT *clut, uchar outputChannels) +{ + if (outputChannels == 4) { + for (qsizetype index = 0; index < clut->table.size(); ++index) { + QColorVector v(tableData[index * 4 + 0] * f, + tableData[index * 4 + 1] * f, + tableData[index * 4 + 2] * f, + tableData[index * 4 + 3] * f); + clut->table[index] = v; + }; + } else { + for (qsizetype index = 0; index < clut->table.size(); ++index) { + QColorVector v(tableData[index * 3 + 0] * f, + tableData[index * 3 + 1] * f, + tableData[index * 3 + 2] * f); + clut->table[index] = v; + }; + } +} + +// very simple version for small values (<=4) of exp. +static constexpr qsizetype intPow(qsizetype x, qsizetype exp) +{ + return (exp <= 1) ? x : x * intPow(x, exp - 1); +} + +// Parses lut8 and lut16 type elements +template<typename T> +static bool parseLutData(const QByteArray &data, const TagEntry &tagEntry, QColorSpacePrivate *colorSpacePrivate, bool isAb) +{ + if (tagEntry.size < sizeof(T)) { + qCWarning(lcIcc) << "Undersized lut8/lut16 tag"; + return false; + } + if (qsizetype(tagEntry.size) > data.size()) { + qCWarning(lcIcc) << "Truncated lut8/lut16 tag"; + return false; + } + using S = std::conditional_t<std::is_same_v<T, Lut8TagData>, uint8_t, uint16_t>; + const T lut = qFromUnaligned<T>(data.constData() + tagEntry.offset); + int inputTableEntries, outputTableEntries, precision; + if constexpr (std::is_same_v<T, Lut8TagData>) { + Q_ASSERT(lut.type == quint32(Tag::mft1)); + if (!colorSpacePrivate->isPcsLab && isAb) { + qCWarning(lcIcc) << "Lut8 can not output XYZ values"; + return false; + } + inputTableEntries = 256; + outputTableEntries = 256; + precision = 1; + } else { + Q_ASSERT(lut.type == quint32(Tag::mft2)); + inputTableEntries = lut.inputTableEntries; + outputTableEntries = lut.outputTableEntries; + if (inputTableEntries < 2 || inputTableEntries > 4096) + return false; + if (outputTableEntries < 2 || outputTableEntries > 4096) + return false; + precision = 2; + } + + bool inTableIsLinear = true, outTableIsLinear = true; + QColorSpacePrivate::TransferElement inTableElement; + QColorSpacePrivate::TransferElement outTableElement; + QColorCLUT clutElement; + QColorMatrix matrixElement; + + matrixElement.r.x = fromFixedS1516(lut.e1); + matrixElement.g.x = fromFixedS1516(lut.e2); + matrixElement.b.x = fromFixedS1516(lut.e3); + matrixElement.r.y = fromFixedS1516(lut.e4); + matrixElement.g.y = fromFixedS1516(lut.e5); + matrixElement.b.y = fromFixedS1516(lut.e6); + matrixElement.r.z = fromFixedS1516(lut.e7); + matrixElement.g.z = fromFixedS1516(lut.e8); + matrixElement.b.z = fromFixedS1516(lut.e9); + if (!colorSpacePrivate->isPcsLab && !isAb && !matrixElement.isValid()) { + qCWarning(lcIcc) << "Invalid matrix values in lut8/lut16"; + return false; + } + + if (lut.inputChannels != 3 && !(isAb && colorSpacePrivate->colorModel == QColorSpace::ColorModel::Cmyk && lut.inputChannels == 4)) { + qCWarning(lcIcc) << "Unsupported lut8/lut16 input channel count" << lut.inputChannels; + return false; + } + + if (lut.outputChannels != 3 && !(!isAb && colorSpacePrivate->colorModel == QColorSpace::ColorModel::Cmyk && lut.outputChannels == 4)) { + qCWarning(lcIcc) << "Unsupported lut8/lut16 output channel count" << lut.outputChannels; + return false; + } + + const qsizetype clutTableSize = intPow(lut.clutGridPoints, lut.inputChannels); + if (tagEntry.size < (sizeof(T) + precision * lut.inputChannels * inputTableEntries + + precision * lut.outputChannels * outputTableEntries + + precision * lut.outputChannels * clutTableSize)) { + qCWarning(lcIcc) << "Undersized lut8/lut16 tag, no room for tables"; + return false; + } + if (colorSpacePrivate->colorModel == QColorSpace::ColorModel::Cmyk && clutTableSize == 0) { + qCWarning(lcIcc) << "Cmyk conversion must have a CLUT"; + return false; + } + + const uint8_t *tableData = reinterpret_cast<const uint8_t *>(data.constData() + tagEntry.offset + sizeof(T)); + + for (int j = 0; j < lut.inputChannels; ++j) { + QList<S> input(inputTableEntries); + qFromBigEndian<S>(tableData, inputTableEntries, input.data()); + QColorTransferTable table(inputTableEntries, input, QColorTransferTable::OneWay); + if (!table.checkValidity()) { + qCWarning(lcIcc) << "Bad input table in lut8/lut16"; + return false; + } + if (!table.isIdentity()) + inTableIsLinear = false; + inTableElement.trc[j] = std::move(table); + tableData += inputTableEntries * precision; + } + + clutElement.table.resize(clutTableSize); + clutElement.gridPointsX = clutElement.gridPointsY = clutElement.gridPointsZ = lut.clutGridPoints; + if (lut.inputChannels == 4) + clutElement.gridPointsW = lut.clutGridPoints; + + if constexpr (std::is_same_v<T, Lut8TagData>) { + parseCLUT(tableData, 1.f / 255.f, &clutElement, lut.outputChannels); + } else { + float f = 1.0f / 65535.f; + if (colorSpacePrivate->isPcsLab && isAb) // Legacy lut16 conversion to Lab + f = 1.0f / 65280.f; + QList<S> clutTable(clutTableSize * lut.outputChannels); + qFromBigEndian<S>(tableData, clutTable.size(), clutTable.data()); + parseCLUT(clutTable.constData(), f, &clutElement, lut.outputChannels); + } + tableData += clutTableSize * lut.outputChannels * precision; + + for (int j = 0; j < lut.outputChannels; ++j) { + QList<S> output(outputTableEntries); + qFromBigEndian<S>(tableData, outputTableEntries, output.data()); + QColorTransferTable table(outputTableEntries, output, QColorTransferTable::OneWay); + if (!table.checkValidity()) { + qCWarning(lcIcc) << "Bad output table in lut8/lut16"; return false; } + if (!table.isIdentity()) + outTableIsLinear = false; + outTableElement.trc[j] = std::move(table); + tableData += outputTableEntries * precision; + } + + if (isAb) { + if (!inTableIsLinear) + colorSpacePrivate->mAB.append(inTableElement); + if (!clutElement.isEmpty()) + colorSpacePrivate->mAB.append(clutElement); + if (!outTableIsLinear || colorSpacePrivate->mAB.isEmpty()) + colorSpacePrivate->mAB.append(outTableElement); + } else { + // The matrix is only to be applied if the input color-space is XYZ + if (!colorSpacePrivate->isPcsLab && !matrixElement.isIdentity()) + colorSpacePrivate->mBA.append(matrixElement); + if (!inTableIsLinear) + colorSpacePrivate->mBA.append(inTableElement); + if (!clutElement.isEmpty()) + colorSpacePrivate->mBA.append(clutElement); + if (!outTableIsLinear || colorSpacePrivate->mBA.isEmpty()) + colorSpacePrivate->mBA.append(outTableElement); + } + return true; +} + +// Parses mAB and mBA type elements +static bool parseMabData(const QByteArray &data, const TagEntry &tagEntry, QColorSpacePrivate *colorSpacePrivate, bool isAb) +{ + if (tagEntry.size < sizeof(mABTagData)) { + qCWarning(lcIcc) << "Undersized mAB/mBA tag"; + return false; + } + if (qsizetype(tagEntry.size) > data.size()) { + qCWarning(lcIcc) << "Truncated mAB/mBA tag"; + return false; + } + const mABTagData mab = qFromUnaligned<mABTagData>(data.constData() + tagEntry.offset); + if ((mab.type != quint32(Tag::mAB_) && isAb) || (mab.type != quint32(Tag::mBA_) && !isAb)){ + qCWarning(lcIcc) << "Bad mAB/mBA content type"; + return false; + } + + if (mab.inputChannels != 3 && !(isAb && colorSpacePrivate->colorModel == QColorSpace::ColorModel::Cmyk && mab.inputChannels == 4)) { + qCWarning(lcIcc) << "Unsupported mAB/mBA input channel count" << mab.inputChannels; + return false; + } + + if (mab.outputChannels != 3 && !(!isAb && colorSpacePrivate->colorModel == QColorSpace::ColorModel::Cmyk && mab.outputChannels == 4)) { + qCWarning(lcIcc) << "Unsupported mAB/mBA output channel count" << mab.outputChannels; + return false; + } + + // These combinations are legal: B, M + Matrix + B, A + Clut + B, A + Clut + M + Matrix + B + if (!mab.bCurvesOffset) { + qCWarning(lcIcc) << "Illegal mAB/mBA without B table"; + return false; + } + if (((bool)mab.matrixOffset != (bool)mab.mCurvesOffset) || + ((bool)mab.aCurvesOffset != (bool)mab.clutOffset)) { + qCWarning(lcIcc) << "Illegal mAB/mBA element combination"; + return false; + } + + if (mab.aCurvesOffset > (tagEntry.size - 3 * sizeof(GenericTagData)) || + mab.bCurvesOffset > (tagEntry.size - 3 * sizeof(GenericTagData)) || + mab.mCurvesOffset > (tagEntry.size - 3 * sizeof(GenericTagData)) || + mab.matrixOffset > (tagEntry.size - 4 * 12) || + mab.clutOffset > (tagEntry.size - 20)) { + qCWarning(lcIcc) << "Illegal mAB/mBA element offset"; + return false; + } + + QColorSpacePrivate::TransferElement bTableElement; + QColorSpacePrivate::TransferElement aTableElement; + QColorCLUT clutElement; + QColorSpacePrivate::TransferElement mTableElement; + QColorMatrix matrixElement; + QColorVector offsetElement; + + auto parseCurves = [&data, &tagEntry] (uint curvesOffset, QColorTrc *table, int channels) { + for (int i = 0; i < channels; ++i) { + if (qsizetype(tagEntry.offset + curvesOffset + 12) > data.size() || curvesOffset + 12 > tagEntry.size) { + qCWarning(lcIcc) << "Space missing for channel curves in mAB/mBA"; + return false; + } + auto size = parseTRC(QByteArrayView(data).sliced(tagEntry.offset + curvesOffset, tagEntry.size - curvesOffset), table[i], QColorTransferTable::OneWay); + if (!size) + return false; + if (size & 2) size += 2; // possible padding + curvesOffset += size; + } return true; + }; + + bool bCurvesAreLinear = true, aCurvesAreLinear = true, mCurvesAreLinear = true; + + // B Curves + if (!parseCurves(mab.bCurvesOffset, bTableElement.trc, isAb ? mab.outputChannels : mab.inputChannels)) { + qCWarning(lcIcc) << "Invalid B curves"; + return false; + } else { + bCurvesAreLinear = bTableElement.trc[0].isIdentity() && bTableElement.trc[1].isIdentity() && bTableElement.trc[2].isIdentity(); } - qCWarning(lcIcc) << "Invalid TRC data type"; + + // A Curves + if (mab.aCurvesOffset) { + if (!parseCurves(mab.aCurvesOffset, aTableElement.trc, isAb ? mab.inputChannels : mab.outputChannels)) { + qCWarning(lcIcc) << "Invalid A curves"; + return false; + } else { + aCurvesAreLinear = aTableElement.trc[0].isIdentity() && aTableElement.trc[1].isIdentity() && aTableElement.trc[2].isIdentity(); + } + } + + // M Curves + if (mab.mCurvesOffset) { + if (!parseCurves(mab.mCurvesOffset, mTableElement.trc, 3)) { + qCWarning(lcIcc) << "Invalid M curves"; + return false; + } else { + mCurvesAreLinear = mTableElement.trc[0].isIdentity() && mTableElement.trc[1].isIdentity() && mTableElement.trc[2].isIdentity(); + } + } + + // Matrix + if (mab.matrixOffset) { + const MatrixElement matrix = qFromUnaligned<MatrixElement>(data.constData() + tagEntry.offset + mab.matrixOffset); + matrixElement.r.x = fromFixedS1516(matrix.e0); + matrixElement.g.x = fromFixedS1516(matrix.e1); + matrixElement.b.x = fromFixedS1516(matrix.e2); + matrixElement.r.y = fromFixedS1516(matrix.e3); + matrixElement.g.y = fromFixedS1516(matrix.e4); + matrixElement.b.y = fromFixedS1516(matrix.e5); + matrixElement.r.z = fromFixedS1516(matrix.e6); + matrixElement.g.z = fromFixedS1516(matrix.e7); + matrixElement.b.z = fromFixedS1516(matrix.e8); + offsetElement.x = fromFixedS1516(matrix.e9); + offsetElement.y = fromFixedS1516(matrix.e10); + offsetElement.z = fromFixedS1516(matrix.e11); + if (!matrixElement.isValid() || !offsetElement.isValid()) { + qCWarning(lcIcc) << "Invalid matrix values in mAB/mBA element"; + return false; + } + } + + // CLUT + if (mab.clutOffset) { + clutElement.gridPointsX = uint8_t(data[tagEntry.offset + mab.clutOffset]); + clutElement.gridPointsY = uint8_t(data[tagEntry.offset + mab.clutOffset + 1]); + clutElement.gridPointsZ = uint8_t(data[tagEntry.offset + mab.clutOffset + 2]); + clutElement.gridPointsW = std::max(uint8_t(data[tagEntry.offset + mab.clutOffset + 3]), uint8_t(1)); + const uchar precision = data[tagEntry.offset + mab.clutOffset + 16]; + if (precision > 2 || precision < 1) { + qCWarning(lcIcc) << "Invalid mAB/mBA element CLUT precision"; + return false; + } + if (clutElement.gridPointsX < 2 || clutElement.gridPointsY < 2 || clutElement.gridPointsZ < 2) { + qCWarning(lcIcc) << "Empty CLUT"; + return false; + } + const qsizetype clutTableSize = clutElement.gridPointsX * clutElement.gridPointsY * clutElement.gridPointsZ * clutElement.gridPointsW; + if ((mab.clutOffset + 20 + clutTableSize * mab.outputChannels * precision) > tagEntry.size) { + qCWarning(lcIcc) << "CLUT oversized for tag"; + return false; + } + + clutElement.table.resize(clutTableSize); + if (precision == 2) { + QList<uint16_t> clutTable(clutTableSize * mab.outputChannels); + qFromBigEndian<uint16_t>(data.constData() + tagEntry.offset + mab.clutOffset + 20, clutTable.size(), clutTable.data()); + parseCLUT(clutTable.constData(), (1.f/65535.f), &clutElement, mab.outputChannels); + } else { + const uint8_t *clutTable = reinterpret_cast<const uint8_t *>(data.constData() + tagEntry.offset + mab.clutOffset + 20); + parseCLUT(clutTable, (1.f/255.f), &clutElement, mab.outputChannels); + } + } else if (colorSpacePrivate->colorModel == QColorSpace::ColorModel::Cmyk) { + qCWarning(lcIcc) << "Cmyk conversion must have a CLUT"; + return false; + } + + if (isAb) { + if (mab.aCurvesOffset) { + if (!aCurvesAreLinear) + colorSpacePrivate->mAB.append(std::move(aTableElement)); + if (!clutElement.isEmpty()) + colorSpacePrivate->mAB.append(std::move(clutElement)); + } + if (mab.mCurvesOffset && mab.outputChannels == 3) { + if (!mCurvesAreLinear) + colorSpacePrivate->mAB.append(std::move(mTableElement)); + if (!matrixElement.isIdentity()) + colorSpacePrivate->mAB.append(std::move(matrixElement)); + if (!offsetElement.isNull()) + colorSpacePrivate->mAB.append(std::move(offsetElement)); + } + if (!bCurvesAreLinear|| colorSpacePrivate->mAB.isEmpty()) + colorSpacePrivate->mAB.append(std::move(bTableElement)); + } else { + if (!bCurvesAreLinear) + colorSpacePrivate->mBA.append(std::move(bTableElement)); + if (mab.mCurvesOffset && mab.inputChannels == 3) { + if (!matrixElement.isIdentity()) + colorSpacePrivate->mBA.append(std::move(matrixElement)); + if (!offsetElement.isNull()) + colorSpacePrivate->mBA.append(std::move(offsetElement)); + if (!mCurvesAreLinear) + colorSpacePrivate->mBA.append(std::move(mTableElement)); + } + if (mab.aCurvesOffset) { + if (!clutElement.isEmpty()) + colorSpacePrivate->mBA.append(std::move(clutElement)); + if (!aCurvesAreLinear) + colorSpacePrivate->mBA.append(std::move(aTableElement)); + } + if (colorSpacePrivate->mBA.isEmpty()) // Ensure non-empty to indicate valid empty transform + colorSpacePrivate->mBA.append(std::move(bTableElement)); + } + + return true; +} + +static bool parseA2B(const QByteArray &data, const TagEntry &tagEntry, QColorSpacePrivate *privat, bool isAb) +{ + const GenericTagData a2bData = qFromUnaligned<GenericTagData>(data.constData() + tagEntry.offset); + if (a2bData.type == quint32(Tag::mft1)) + return parseLutData<Lut8TagData>(data, tagEntry, privat, isAb); + else if (a2bData.type == quint32(Tag::mft2)) + return parseLutData<Lut16TagData>(data, tagEntry, privat, isAb); + else if (a2bData.type == quint32(Tag::mAB_) || a2bData.type == quint32(Tag::mBA_)) + return parseMabData(data, tagEntry, privat, isAb); + + qCWarning(lcIcc) << "fromIccProfile: Unknown A2B/B2A data type"; return false; } -bool parseDesc(const QByteArray &data, const TagEntry &tagEntry, QString &descName) +static bool parseDesc(const QByteArray &data, const TagEntry &tagEntry, QString &descName) { const GenericTagData tag = qFromUnaligned<GenericTagData>(data.constData() + tagEntry.offset); @@ -581,7 +1088,7 @@ bool parseDesc(const QByteArray &data, const TagEntry &tagEntry, QString &descNa const MlucTagData mluc = qFromUnaligned<MlucTagData>(data.constData() + tagEntry.offset); if (mluc.recordCount < 1) return false; - if (mluc.recordSize < 12) + if (mluc.recordSize != 12) return false; // We just use the primary record regardless of language or country. const quint32 stringOffset = mluc.records[0].offset; @@ -601,6 +1108,147 @@ bool parseDesc(const QByteArray &data, const TagEntry &tagEntry, QString &descNa return true; } +static bool parseRgbMatrix(const QByteArray &data, const QHash<Tag, TagEntry> &tagIndex, QColorSpacePrivate *colorspaceDPtr) +{ + // Parse XYZ tags + if (!parseXyzData(data, tagIndex[Tag::rXYZ], colorspaceDPtr->toXyz.r)) + return false; + if (!parseXyzData(data, tagIndex[Tag::gXYZ], colorspaceDPtr->toXyz.g)) + return false; + if (!parseXyzData(data, tagIndex[Tag::bXYZ], colorspaceDPtr->toXyz.b)) + return false; + if (!parseXyzData(data, tagIndex[Tag::wtpt], colorspaceDPtr->whitePoint)) + return false; + if (!colorspaceDPtr->toXyz.isValid() || !colorspaceDPtr->whitePoint.isValid() || colorspaceDPtr->whitePoint.isNull()) { + qCWarning(lcIcc) << "Invalid XYZ values in RGB matrix"; + return false; + } + + colorspaceDPtr->primaries = QColorSpace::Primaries::Custom; + if (colorspaceDPtr->toXyz == QColorMatrix::toXyzFromSRgb()) { + qCDebug(lcIcc) << "fromIccProfile: sRGB primaries detected"; + colorspaceDPtr->primaries = QColorSpace::Primaries::SRgb; + } else if (colorspaceDPtr->toXyz == QColorMatrix::toXyzFromAdobeRgb()) { + qCDebug(lcIcc) << "fromIccProfile: Adobe RGB primaries detected"; + colorspaceDPtr->primaries = QColorSpace::Primaries::AdobeRgb; + } else if (colorspaceDPtr->toXyz == QColorMatrix::toXyzFromDciP3D65()) { + qCDebug(lcIcc) << "fromIccProfile: DCI-P3 D65 primaries detected"; + colorspaceDPtr->primaries = QColorSpace::Primaries::DciP3D65; + } + if (colorspaceDPtr->toXyz == QColorMatrix::toXyzFromProPhotoRgb()) { + qCDebug(lcIcc) << "fromIccProfile: ProPhoto RGB primaries detected"; + colorspaceDPtr->primaries = QColorSpace::Primaries::ProPhotoRgb; + } + return true; +} + +static bool parseGrayMatrix(const QByteArray &data, const QHash<Tag, TagEntry> &tagIndex, QColorSpacePrivate *colorspaceDPtr) +{ + QColorVector whitePoint; + if (!parseXyzData(data, tagIndex[Tag::wtpt], whitePoint)) + return false; + if (!whitePoint.isValid() || !qFuzzyCompare(whitePoint.y, 1.0f) || (1.0f + whitePoint.z + whitePoint.x) == 0.0f) { + qCWarning(lcIcc) << "fromIccProfile: Invalid ICC profile - gray white-point not normalized"; + return false; + } + colorspaceDPtr->primaries = QColorSpace::Primaries::Custom; + colorspaceDPtr->whitePoint = whitePoint; + return true; +} + +static bool parseChad(const QByteArray &data, const TagEntry &tagEntry, QColorSpacePrivate *colorspaceDPtr) +{ + if (tagEntry.size < sizeof(Sf32TagData) || qsizetype(tagEntry.size) > data.size()) + return false; + const Sf32TagData chadtag = qFromUnaligned<Sf32TagData>(data.constData() + tagEntry.offset); + if (chadtag.type != uint32_t(Tag::sf32)) { + qCWarning(lcIcc, "fromIccProfile: bad chad data type"); + return false; + } + QColorMatrix chad; + chad.r.x = fromFixedS1516(chadtag.value[0]); + chad.g.x = fromFixedS1516(chadtag.value[1]); + chad.b.x = fromFixedS1516(chadtag.value[2]); + chad.r.y = fromFixedS1516(chadtag.value[3]); + chad.g.y = fromFixedS1516(chadtag.value[4]); + chad.b.y = fromFixedS1516(chadtag.value[5]); + chad.r.z = fromFixedS1516(chadtag.value[6]); + chad.g.z = fromFixedS1516(chadtag.value[7]); + chad.b.z = fromFixedS1516(chadtag.value[8]); + + if (!chad.isValid()) { + qCWarning(lcIcc, "fromIccProfile: invalid chad matrix"); + return false; + } + colorspaceDPtr->chad = chad; + return true; +} + +static bool parseTRCs(const QByteArray &data, const QHash<Tag, TagEntry> &tagIndex, QColorSpacePrivate *colorspaceDPtr, bool isColorSpaceTypeGray) +{ + TagEntry rTrc; + TagEntry gTrc; + TagEntry bTrc; + if (isColorSpaceTypeGray) { + rTrc = tagIndex[Tag::kTRC]; + gTrc = tagIndex[Tag::kTRC]; + bTrc = tagIndex[Tag::kTRC]; + } else if (tagIndex.contains(Tag::aarg) && tagIndex.contains(Tag::aagg) && tagIndex.contains(Tag::aabg)) { + // Apple extension for parametric version of TRCs in ICCv2: + rTrc = tagIndex[Tag::aarg]; + gTrc = tagIndex[Tag::aagg]; + bTrc = tagIndex[Tag::aabg]; + } else { + rTrc = tagIndex[Tag::rTRC]; + gTrc = tagIndex[Tag::gTRC]; + bTrc = tagIndex[Tag::bTRC]; + } + + QColorTrc rCurve; + QColorTrc gCurve; + QColorTrc bCurve; + if (!parseTRC(QByteArrayView(data).sliced(rTrc.offset, rTrc.size), rCurve, QColorTransferTable::TwoWay)) { + qCWarning(lcIcc) << "fromIccProfile: Invalid rTRC"; + return false; + } + if (!parseTRC(QByteArrayView(data).sliced(gTrc.offset, gTrc.size), gCurve, QColorTransferTable::TwoWay)) { + qCWarning(lcIcc) << "fromIccProfile: Invalid gTRC"; + return false; + } + if (!parseTRC(QByteArrayView(data).sliced(bTrc.offset, bTrc.size), bCurve, QColorTransferTable::TwoWay)) { + qCWarning(lcIcc) << "fromIccProfile: Invalid bTRC"; + return false; + } + if (rCurve == gCurve && gCurve == bCurve) { + if (rCurve.isIdentity()) { + qCDebug(lcIcc) << "fromIccProfile: Linear gamma detected"; + colorspaceDPtr->trc[0] = QColorTransferFunction(); + colorspaceDPtr->transferFunction = QColorSpace::TransferFunction::Linear; + colorspaceDPtr->gamma = 1.0f; + } else if (rCurve.m_type == QColorTrc::Type::Function && rCurve.m_fun.isGamma()) { + qCDebug(lcIcc) << "fromIccProfile: Simple gamma detected"; + colorspaceDPtr->trc[0] = QColorTransferFunction::fromGamma(rCurve.m_fun.m_g); + colorspaceDPtr->transferFunction = QColorSpace::TransferFunction::Gamma; + colorspaceDPtr->gamma = rCurve.m_fun.m_g; + } else if (rCurve.m_type == QColorTrc::Type::Function && rCurve.m_fun.isSRgb()) { + qCDebug(lcIcc) << "fromIccProfile: sRGB gamma detected"; + colorspaceDPtr->trc[0] = QColorTransferFunction::fromSRgb(); + colorspaceDPtr->transferFunction = QColorSpace::TransferFunction::SRgb; + } else { + colorspaceDPtr->trc[0] = rCurve; + colorspaceDPtr->transferFunction = QColorSpace::TransferFunction::Custom; + } + colorspaceDPtr->trc[1] = colorspaceDPtr->trc[0]; + colorspaceDPtr->trc[2] = colorspaceDPtr->trc[0]; + } else { + colorspaceDPtr->trc[0] = rCurve; + colorspaceDPtr->trc[1] = gCurve; + colorspaceDPtr->trc[2] = bCurve; + colorspaceDPtr->transferFunction = QColorSpace::TransferFunction::Custom; + } + return true; +} + bool fromIccProfile(const QByteArray &data, QColorSpace *colorSpace) { if (data.size() < qsizetype(sizeof(ICCProfileHeader))) { @@ -657,146 +1305,92 @@ bool fromIccProfile(const QByteArray &data, QColorSpace *colorSpace) tagIndex.insert(Tag(quint32(tagTable.signature)), { tagTable.offset, tagTable.size }); } - // Check the profile is three-component matrix based (what we currently support): + bool threeComponentMatrix = true; + if (header.inputColorSpace == uint(ColorSpaceType::Rgb)) { + // Check the profile is three-component matrix based: if (!tagIndex.contains(Tag::rXYZ) || !tagIndex.contains(Tag::gXYZ) || !tagIndex.contains(Tag::bXYZ) || !tagIndex.contains(Tag::rTRC) || !tagIndex.contains(Tag::gTRC) || !tagIndex.contains(Tag::bTRC) || - !tagIndex.contains(Tag::wtpt)) { - qCInfo(lcIcc) << "fromIccProfile: Unsupported ICC profile - not three component matrix based"; - return false; + !tagIndex.contains(Tag::wtpt) || header.pcs == uint(Tag::Lab_)) { + threeComponentMatrix = false; + // Check if the profile is valid n-LUT based: + if (!tagIndex.contains(Tag::A2B0)) { + qCWarning(lcIcc) << "fromIccProfile: Invalid ICC profile - neither valid three component nor n-LUT"; + return false; + } } - } else { - Q_ASSERT(header.inputColorSpace == uint(ColorSpaceType::Gray)); + } else if (header.inputColorSpace == uint(ColorSpaceType::Gray)) { if (!tagIndex.contains(Tag::kTRC) || !tagIndex.contains(Tag::wtpt)) { qCWarning(lcIcc) << "fromIccProfile: Invalid ICC profile - not valid gray scale based"; return false; } + } else if (header.inputColorSpace == uint(ColorSpaceType::Cmyk)) { + threeComponentMatrix = false; + if (!tagIndex.contains(Tag::A2B0)) { + qCWarning(lcIcc) << "fromIccProfile: Invalid ICC profile - CMYK, not n-LUT"; + return false; + } + } else { + Q_UNREACHABLE(); } colorSpace->detach(); QColorSpacePrivate *colorspaceDPtr = QColorSpacePrivate::get(*colorSpace); - if (header.inputColorSpace == uint(ColorSpaceType::Rgb)) { - // Parse XYZ tags - if (!parseXyzData(data, tagIndex[Tag::rXYZ], colorspaceDPtr->toXyz.r)) - return false; - if (!parseXyzData(data, tagIndex[Tag::gXYZ], colorspaceDPtr->toXyz.g)) - return false; - if (!parseXyzData(data, tagIndex[Tag::bXYZ], colorspaceDPtr->toXyz.b)) - return false; - if (!parseXyzData(data, tagIndex[Tag::wtpt], colorspaceDPtr->whitePoint)) - return false; + if (threeComponentMatrix) { + colorspaceDPtr->isPcsLab = false; + colorspaceDPtr->transformModel = QColorSpace::TransformModel::ThreeComponentMatrix; - colorspaceDPtr->primaries = QColorSpace::Primaries::Custom; - if (colorspaceDPtr->toXyz == QColorMatrix::toXyzFromSRgb()) { - qCDebug(lcIcc) << "fromIccProfile: sRGB primaries detected"; - colorspaceDPtr->primaries = QColorSpace::Primaries::SRgb; - } else if (colorspaceDPtr->toXyz == QColorMatrix::toXyzFromAdobeRgb()) { - qCDebug(lcIcc) << "fromIccProfile: Adobe RGB primaries detected"; - colorspaceDPtr->primaries = QColorSpace::Primaries::AdobeRgb; - } else if (colorspaceDPtr->toXyz == QColorMatrix::toXyzFromDciP3D65()) { - qCDebug(lcIcc) << "fromIccProfile: DCI-P3 D65 primaries detected"; - colorspaceDPtr->primaries = QColorSpace::Primaries::DciP3D65; - } - if (colorspaceDPtr->toXyz == QColorMatrix::toXyzFromProPhotoRgb()) { - qCDebug(lcIcc) << "fromIccProfile: ProPhoto RGB primaries detected"; - colorspaceDPtr->primaries = QColorSpace::Primaries::ProPhotoRgb; - } - } else { - // We will use sRGB primaries and fit to match the given white-point if - // it doesn't match sRGB's. - QColorVector whitePoint; - if (!parseXyzData(data, tagIndex[Tag::wtpt], whitePoint)) - return false; - if (!qFuzzyCompare(whitePoint.y, 1.0f) || (1.0f + whitePoint.z + whitePoint.x) == 0.0f) { - qCWarning(lcIcc) << "fromIccProfile: Invalid ICC profile - gray white-point not normalized"; - return false; - } - if (whitePoint == QColorVector::D65()) { - colorspaceDPtr->primaries = QColorSpace::Primaries::SRgb; + if (header.inputColorSpace == uint(ColorSpaceType::Rgb)) { + if (!parseRgbMatrix(data, tagIndex, colorspaceDPtr)) + return false; + colorspaceDPtr->colorModel = QColorSpace::ColorModel::Rgb; + } else if (header.inputColorSpace == uint(ColorSpaceType::Gray)) { + if (!parseGrayMatrix(data, tagIndex, colorspaceDPtr)) + return false; + colorspaceDPtr->colorModel = QColorSpace::ColorModel::Gray; } else { - colorspaceDPtr->primaries = QColorSpace::Primaries::Custom; - // Calculate chromaticity from xyz (assuming y == 1.0f). - float y = 1.0f / (1.0f + whitePoint.z + whitePoint.x); - float x = whitePoint.x * y; - QColorSpacePrimaries primaries(QColorSpace::Primaries::SRgb); - primaries.whitePoint = QPointF(x,y); - if (!primaries.areValid()) { - qCWarning(lcIcc, "fromIccProfile: Invalid ICC profile - invalid white-point(%f, %f)", x, y); + Q_UNREACHABLE(); + } + if (auto it = tagIndex.constFind(Tag::chad); it != tagIndex.constEnd()) { + if (!parseChad(data, it.value(), colorspaceDPtr)) return false; - } - colorspaceDPtr->toXyz = primaries.toXyzMatrix(); + } else { + colorspaceDPtr->chad = QColorMatrix::chromaticAdaptation(colorspaceDPtr->whitePoint); } - } - // Reset the matrix to our canonical values: - if (colorspaceDPtr->primaries != QColorSpace::Primaries::Custom) - colorspaceDPtr->setToXyzMatrix(); + if (colorspaceDPtr->colorModel == QColorSpace::ColorModel::Gray) + colorspaceDPtr->toXyz = colorspaceDPtr->chad; - // Parse TRC tags - TagEntry rTrc; - TagEntry gTrc; - TagEntry bTrc; - if (header.inputColorSpace == uint(ColorSpaceType::Gray)) { - rTrc = tagIndex[Tag::kTRC]; - gTrc = tagIndex[Tag::kTRC]; - bTrc = tagIndex[Tag::kTRC]; - } else if (tagIndex.contains(Tag::aarg) && tagIndex.contains(Tag::aagg) && tagIndex.contains(Tag::aabg)) { - // Apple extension for parametric version of TRCs in ICCv2: - rTrc = tagIndex[Tag::aarg]; - gTrc = tagIndex[Tag::aagg]; - bTrc = tagIndex[Tag::aabg]; + // Reset the matrix to our canonical values: + if (colorspaceDPtr->primaries != QColorSpace::Primaries::Custom) + colorspaceDPtr->setToXyzMatrix(); + + if (!parseTRCs(data, tagIndex, colorspaceDPtr, header.inputColorSpace == uint(ColorSpaceType::Gray))) + return false; } else { - rTrc = tagIndex[Tag::rTRC]; - gTrc = tagIndex[Tag::gTRC]; - bTrc = tagIndex[Tag::bTRC]; - } + colorspaceDPtr->isPcsLab = (header.pcs == uint(Tag::Lab_)); + colorspaceDPtr->transformModel = QColorSpace::TransformModel::ElementListProcessing; + if (header.inputColorSpace == uint(ColorSpaceType::Cmyk)) + colorspaceDPtr->colorModel = QColorSpace::ColorModel::Cmyk; + else + colorspaceDPtr->colorModel = QColorSpace::ColorModel::Rgb; - QColorTrc rCurve; - QColorTrc gCurve; - QColorTrc bCurve; - if (!parseTRC(data, rTrc, rCurve)) { - qCWarning(lcIcc) << "fromIccProfile: Invalid rTRC"; - return false; - } - if (!parseTRC(data, gTrc, gCurve)) { - qCWarning(lcIcc) << "fromIccProfile: Invalid gTRC"; - return false; - } - if (!parseTRC(data, bTrc, bCurve)) { - qCWarning(lcIcc) << "fromIccProfile: Invalid bTRC"; - return false; - } - if (rCurve == gCurve && gCurve == bCurve && rCurve.m_type == QColorTrc::Type::Function) { - if (rCurve.m_fun.isLinear()) { - qCDebug(lcIcc) << "fromIccProfile: Linear gamma detected"; - colorspaceDPtr->trc[0] = QColorTransferFunction(); - colorspaceDPtr->transferFunction = QColorSpace::TransferFunction::Linear; - colorspaceDPtr->gamma = 1.0f; - } else if (rCurve.m_fun.isGamma()) { - qCDebug(lcIcc) << "fromIccProfile: Simple gamma detected"; - colorspaceDPtr->trc[0] = QColorTransferFunction::fromGamma(rCurve.m_fun.m_g); - colorspaceDPtr->transferFunction = QColorSpace::TransferFunction::Gamma; - colorspaceDPtr->gamma = rCurve.m_fun.m_g; - } else if (rCurve.m_fun.isSRgb()) { - qCDebug(lcIcc) << "fromIccProfile: sRGB gamma detected"; - colorspaceDPtr->trc[0] = QColorTransferFunction::fromSRgb(); - colorspaceDPtr->transferFunction = QColorSpace::TransferFunction::SRgb; - } else { - colorspaceDPtr->trc[0] = rCurve; - colorspaceDPtr->transferFunction = QColorSpace::TransferFunction::Custom; + // Only parse the default perceptual transform for now + if (!parseA2B(data, tagIndex[Tag::A2B0], colorspaceDPtr, true)) + return false; + if (auto it = tagIndex.constFind(Tag::B2A0); it != tagIndex.constEnd()) { + if (!parseA2B(data, it.value(), colorspaceDPtr, false)) + return false; } - colorspaceDPtr->trc[1] = colorspaceDPtr->trc[0]; - colorspaceDPtr->trc[2] = colorspaceDPtr->trc[0]; - } else { - colorspaceDPtr->trc[0] = rCurve; - colorspaceDPtr->trc[1] = gCurve; - colorspaceDPtr->trc[2] = bCurve; - colorspaceDPtr->transferFunction = QColorSpace::TransferFunction::Custom; + if (auto it = tagIndex.constFind(Tag::wtpt); it != tagIndex.constEnd()) { + if (!parseXyzData(data, it.value(), colorspaceDPtr->whitePoint)) + return false; + } } - if (tagIndex.contains(Tag::desc)) { - if (!parseDesc(data, tagIndex[Tag::desc], colorspaceDPtr->description)) + if (auto it = tagIndex.constFind(Tag::desc); it != tagIndex.constEnd()) { + if (!parseDesc(data, it.value(), colorspaceDPtr->description)) qCWarning(lcIcc) << "fromIccProfile: Failed to parse description"; else qCDebug(lcIcc) << "fromIccProfile: Description" << colorspaceDPtr->description; @@ -808,6 +1402,7 @@ bool fromIccProfile(const QByteArray &data, QColorSpace *colorSpace) colorspaceDPtr->iccProfile = data; + Q_ASSERT(colorspaceDPtr->isValid()); return true; } diff --git a/src/gui/painting/qimageeffects.cpp b/src/gui/painting/qimageeffects.cpp new file mode 100644 index 0000000000..7c2b947e08 --- /dev/null +++ b/src/gui/painting/qimageeffects.cpp @@ -0,0 +1,327 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "qmath.h" +#include "qdrawhelper_p.h" +#include "qmemrotate_p.h" +#include "qpainter.h" + +#include <memory> + +QT_BEGIN_NAMESPACE + +namespace { + +template <int shift> +inline int qt_static_shift(int value) +{ + if (shift == 0) + return value; + else if (shift > 0) + return value << (uint(shift) & 0x1f); + else + return value >> (uint(-shift) & 0x1f); +} + +template<int aprec, int zprec> +inline void qt_blurinner(uchar *bptr, int &zR, int &zG, int &zB, int &zA, int alpha) +{ + QRgb *pixel = (QRgb *)bptr; + +#define Z_MASK (0xff << zprec) + const int A_zprec = qt_static_shift<zprec - 24>(*pixel) & Z_MASK; + const int R_zprec = qt_static_shift<zprec - 16>(*pixel) & Z_MASK; + const int G_zprec = qt_static_shift<zprec - 8>(*pixel) & Z_MASK; + const int B_zprec = qt_static_shift<zprec>(*pixel) & Z_MASK; +#undef Z_MASK + + const int zR_zprec = zR >> aprec; + const int zG_zprec = zG >> aprec; + const int zB_zprec = zB >> aprec; + const int zA_zprec = zA >> aprec; + + zR += alpha * (R_zprec - zR_zprec); + zG += alpha * (G_zprec - zG_zprec); + zB += alpha * (B_zprec - zB_zprec); + zA += alpha * (A_zprec - zA_zprec); + +#define ZA_MASK (0xff << (zprec + aprec)) + *pixel = + qt_static_shift<24 - zprec - aprec>(zA & ZA_MASK) + | qt_static_shift<16 - zprec - aprec>(zR & ZA_MASK) + | qt_static_shift<8 - zprec - aprec>(zG & ZA_MASK) + | qt_static_shift<-zprec - aprec>(zB & ZA_MASK); +#undef ZA_MASK +} + +const int alphaIndex = (QSysInfo::ByteOrder == QSysInfo::BigEndian ? 0 : 3); + +template<int aprec, int zprec> +inline void qt_blurinner_alphaOnly(uchar *bptr, int &z, int alpha) +{ + const int A_zprec = int(*(bptr)) << zprec; + const int z_zprec = z >> aprec; + z += alpha * (A_zprec - z_zprec); + *(bptr) = z >> (zprec + aprec); +} + +template<int aprec, int zprec, bool alphaOnly> +inline void qt_blurrow(QImage & im, int line, int alpha) +{ + uchar *bptr = im.scanLine(line); + + int zR = 0, zG = 0, zB = 0, zA = 0; + + if (alphaOnly && im.format() != QImage::Format_Indexed8) + bptr += alphaIndex; + + const int stride = im.depth() >> 3; + const int im_width = im.width(); + for (int index = 0; index < im_width; ++index) { + if (alphaOnly) + qt_blurinner_alphaOnly<aprec, zprec>(bptr, zA, alpha); + else + qt_blurinner<aprec, zprec>(bptr, zR, zG, zB, zA, alpha); + bptr += stride; + } + + bptr -= stride; + + for (int index = im_width - 2; index >= 0; --index) { + bptr -= stride; + if (alphaOnly) + qt_blurinner_alphaOnly<aprec, zprec>(bptr, zA, alpha); + else + qt_blurinner<aprec, zprec>(bptr, zR, zG, zB, zA, alpha); + } +} + +/* +* expblur(QImage &img, int radius) +* +* Based on exponential blur algorithm by Jani Huhtanen +* +* In-place blur of image 'img' with kernel +* of approximate radius 'radius'. +* +* Blurs with two sided exponential impulse +* response. +* +* aprec = precision of alpha parameter +* in fixed-point format 0.aprec +* +* zprec = precision of state parameters +* zR,zG,zB and zA in fp format 8.zprec +*/ +template <int aprec, int zprec, bool alphaOnly> +void expblur(QImage &img, qreal radius, bool improvedQuality = false, int transposed = 0) +{ + // halve the radius if we're using two passes + if (improvedQuality) + radius *= qreal(0.5); + + Q_ASSERT(img.format() == QImage::Format_ARGB32_Premultiplied + || img.format() == QImage::Format_RGB32 + || img.format() == QImage::Format_Indexed8 + || img.format() == QImage::Format_Grayscale8); + + // choose the alpha such that pixels at radius distance from a fully + // saturated pixel will have an alpha component of no greater than + // the cutOffIntensity + const qreal cutOffIntensity = 2; + int alpha = radius <= qreal(1e-5) + ? ((1 << aprec)-1) + : qRound((1<<aprec)*(1 - qPow(cutOffIntensity * (1 / qreal(255)), 1 / radius))); + + int img_height = img.height(); + for (int row = 0; row < img_height; ++row) { + for (int i = 0; i <= int(improvedQuality); ++i) + qt_blurrow<aprec, zprec, alphaOnly>(img, row, alpha); + } + + QImage temp(img.height(), img.width(), img.format()); + temp.setDevicePixelRatio(img.devicePixelRatio()); + if (transposed >= 0) { + if (img.depth() == 8) { + qt_memrotate270(reinterpret_cast<const quint8*>(img.bits()), + img.width(), img.height(), img.bytesPerLine(), + reinterpret_cast<quint8*>(temp.bits()), + temp.bytesPerLine()); + } else { + qt_memrotate270(reinterpret_cast<const quint32*>(img.bits()), + img.width(), img.height(), img.bytesPerLine(), + reinterpret_cast<quint32*>(temp.bits()), + temp.bytesPerLine()); + } + } else { + if (img.depth() == 8) { + qt_memrotate90(reinterpret_cast<const quint8*>(img.bits()), + img.width(), img.height(), img.bytesPerLine(), + reinterpret_cast<quint8*>(temp.bits()), + temp.bytesPerLine()); + } else { + qt_memrotate90(reinterpret_cast<const quint32*>(img.bits()), + img.width(), img.height(), img.bytesPerLine(), + reinterpret_cast<quint32*>(temp.bits()), + temp.bytesPerLine()); + } + } + + img_height = temp.height(); + for (int row = 0; row < img_height; ++row) { + for (int i = 0; i <= int(improvedQuality); ++i) + qt_blurrow<aprec, zprec, alphaOnly>(temp, row, alpha); + } + + if (transposed == 0) { + if (img.depth() == 8) { + qt_memrotate90(reinterpret_cast<const quint8*>(temp.bits()), + temp.width(), temp.height(), temp.bytesPerLine(), + reinterpret_cast<quint8*>(img.bits()), + img.bytesPerLine()); + } else { + qt_memrotate90(reinterpret_cast<const quint32*>(temp.bits()), + temp.width(), temp.height(), temp.bytesPerLine(), + reinterpret_cast<quint32*>(img.bits()), + img.bytesPerLine()); + } + } else { + img = temp; + } +} + +} // namespace + +#define AVG(a,b) ( ((((a)^(b)) & 0xfefefefeUL) >> 1) + ((a)&(b)) ) +#define AVG16(a,b) ( ((((a)^(b)) & 0xf7deUL) >> 1) + ((a)&(b)) ) + +QImage qt_halfScaled(const QImage &source) +{ + if (source.width() < 2 || source.height() < 2) + return QImage(); + + QImage srcImage = source; + + if (source.format() == QImage::Format_Indexed8 || source.format() == QImage::Format_Grayscale8) { + // assumes grayscale + QImage dest(source.width() / 2, source.height() / 2, srcImage.format()); + dest.setDevicePixelRatio(source.devicePixelRatio()); + + const uchar *src = reinterpret_cast<const uchar*>(const_cast<const QImage &>(srcImage).bits()); + qsizetype sx = srcImage.bytesPerLine(); + qsizetype sx2 = sx << 1; + + uchar *dst = reinterpret_cast<uchar*>(dest.bits()); + qsizetype dx = dest.bytesPerLine(); + int ww = dest.width(); + int hh = dest.height(); + + for (int y = hh; y; --y, dst += dx, src += sx2) { + const uchar *p1 = src; + const uchar *p2 = src + sx; + uchar *q = dst; + for (int x = ww; x; --x, ++q, p1 += 2, p2 += 2) + *q = ((int(p1[0]) + int(p1[1]) + int(p2[0]) + int(p2[1])) + 2) >> 2; + } + + return dest; + } else if (source.format() == QImage::Format_ARGB8565_Premultiplied) { + QImage dest(source.width() / 2, source.height() / 2, srcImage.format()); + dest.setDevicePixelRatio(source.devicePixelRatio()); + + const uchar *src = reinterpret_cast<const uchar*>(const_cast<const QImage &>(srcImage).bits()); + qsizetype sx = srcImage.bytesPerLine(); + qsizetype sx2 = sx << 1; + + uchar *dst = reinterpret_cast<uchar*>(dest.bits()); + qsizetype dx = dest.bytesPerLine(); + int ww = dest.width(); + int hh = dest.height(); + + for (int y = hh; y; --y, dst += dx, src += sx2) { + const uchar *p1 = src; + const uchar *p2 = src + sx; + uchar *q = dst; + for (int x = ww; x; --x, q += 3, p1 += 6, p2 += 6) { + // alpha + q[0] = AVG(AVG(p1[0], p1[3]), AVG(p2[0], p2[3])); + // rgb + const quint16 p16_1 = (p1[2] << 8) | p1[1]; + const quint16 p16_2 = (p1[5] << 8) | p1[4]; + const quint16 p16_3 = (p2[2] << 8) | p2[1]; + const quint16 p16_4 = (p2[5] << 8) | p2[4]; + const quint16 result = AVG16(AVG16(p16_1, p16_2), AVG16(p16_3, p16_4)); + q[1] = result & 0xff; + q[2] = result >> 8; + } + } + + return dest; + } else if (source.format() != QImage::Format_ARGB32_Premultiplied + && source.format() != QImage::Format_RGB32) + { + srcImage = source.convertToFormat(QImage::Format_ARGB32_Premultiplied); + } + + QImage dest(source.width() / 2, source.height() / 2, srcImage.format()); + dest.setDevicePixelRatio(source.devicePixelRatio()); + + const quint32 *src = reinterpret_cast<const quint32*>(const_cast<const QImage &>(srcImage).bits()); + qsizetype sx = srcImage.bytesPerLine() >> 2; + qsizetype sx2 = sx << 1; + + quint32 *dst = reinterpret_cast<quint32*>(dest.bits()); + qsizetype dx = dest.bytesPerLine() >> 2; + int ww = dest.width(); + int hh = dest.height(); + + for (int y = hh; y; --y, dst += dx, src += sx2) { + const quint32 *p1 = src; + const quint32 *p2 = src + sx; + quint32 *q = dst; + for (int x = ww; x; --x, q++, p1 += 2, p2 += 2) + *q = AVG(AVG(p1[0], p1[1]), AVG(p2[0], p2[1])); + } + + return dest; +} + +#undef AVG +#undef AVG16 + +Q_GUI_EXPORT void qt_blurImage(QPainter *p, QImage &blurImage, qreal radius, bool quality, bool alphaOnly, int transposed = 0) +{ + if (blurImage.format() != QImage::Format_ARGB32_Premultiplied + && blurImage.format() != QImage::Format_RGB32) + { + blurImage = std::move(blurImage).convertToFormat(QImage::Format_ARGB32_Premultiplied); + } + + qreal scale = 1; + if (radius >= 4 && blurImage.width() >= 2 && blurImage.height() >= 2) { + blurImage = qt_halfScaled(blurImage); + scale = 2; + radius *= qreal(0.5); + } + + if (alphaOnly) + expblur<12, 10, true>(blurImage, radius, quality, transposed); + else + expblur<12, 10, false>(blurImage, radius, quality, transposed); + + if (p) { + p->scale(scale, scale); + p->setRenderHint(QPainter::SmoothPixmapTransform); + p->drawImage(QRect(QPoint(0, 0), blurImage.deviceIndependentSize().toSize()), blurImage); + } +} + +Q_GUI_EXPORT void qt_blurImage(QImage &blurImage, qreal radius, bool quality, int transposed = 0) +{ + if (blurImage.format() == QImage::Format_Indexed8 || blurImage.format() == QImage::Format_Grayscale8) + expblur<12, 10, true>(blurImage, radius, quality, transposed); + else + expblur<12, 10, false>(blurImage, radius, quality, transposed); +} + +QT_END_NAMESPACE diff --git a/src/gui/painting/qimagescale.cpp b/src/gui/painting/qimagescale.cpp index 80d1a67a3f..a636635fd5 100644 --- a/src/gui/painting/qimagescale.cpp +++ b/src/gui/painting/qimagescale.cpp @@ -10,8 +10,9 @@ #include "qrgbafloat.h" #if QT_CONFIG(thread) && !defined(Q_OS_WASM) -#include "qsemaphore.h" -#include "qthreadpool.h" +#include <qsemaphore.h> +#include <qthreadpool.h> +#include <private/qthreadpool_p.h> #endif QT_BEGIN_NAMESPACE @@ -273,7 +274,7 @@ static inline void multithread_pixels_function(QImageScaleInfo *isi, int dh, con #if QT_CONFIG(thread) && !defined(Q_OS_WASM) int segments = (qsizetype(isi->sh) * isi->sw) / (1<<16); segments = std::min(segments, dh); - QThreadPool *threadPool = QThreadPool::globalInstance(); + QThreadPool *threadPool = QThreadPoolPrivate::qtGuiInstance(); if (segments > 1 && threadPool && !threadPool->contains(QThread::currentThread())) { QSemaphore semaphore; int y = 0; diff --git a/src/gui/painting/qimagescale_neon.cpp b/src/gui/painting/qimagescale_neon.cpp index c8d364d56c..074b819862 100644 --- a/src/gui/painting/qimagescale_neon.cpp +++ b/src/gui/painting/qimagescale_neon.cpp @@ -6,8 +6,9 @@ #include <private/qsimd_p.h> #if QT_CONFIG(thread) && !defined(Q_OS_WASM) -#include "qsemaphore.h" -#include "qthreadpool.h" +#include <qsemaphore.h> +#include <qthreadpool.h> +#include <private/qthreadpool_p.h> #endif #if defined(__ARM_NEON__) @@ -22,7 +23,7 @@ static inline void multithread_pixels_function(QImageScaleInfo *isi, int dh, con #if QT_CONFIG(thread) && !defined(Q_OS_WASM) int segments = (qsizetype(isi->sh) * isi->sw) / (1<<16); segments = std::min(segments, dh); - QThreadPool *threadPool = QThreadPool::globalInstance(); + QThreadPool *threadPool = QThreadPoolPrivate::qtGuiInstance(); if (segments > 1 && threadPool && !threadPool->contains(QThread::currentThread())) { QSemaphore semaphore; int y = 0; diff --git a/src/gui/painting/qimagescale_sse4.cpp b/src/gui/painting/qimagescale_sse4.cpp index f55290b46c..982e533a32 100644 --- a/src/gui/painting/qimagescale_sse4.cpp +++ b/src/gui/painting/qimagescale_sse4.cpp @@ -7,8 +7,9 @@ #include <private/qsimd_p.h> #if QT_CONFIG(thread) && !defined(Q_OS_WASM) -#include "qsemaphore.h" -#include "qthreadpool.h" +#include <qsemaphore.h> +#include <qthreadpool.h> +#include <private/qthreadpool_p.h> #endif #if defined(QT_COMPILER_SUPPORTS_SSE4_1) @@ -23,7 +24,7 @@ static inline void multithread_pixels_function(QImageScaleInfo *isi, int dh, con #if QT_CONFIG(thread) && !defined(Q_OS_WASM) int segments = (qsizetype(isi->sh) * isi->sw) / (1<<16); segments = std::min(segments, dh); - QThreadPool *threadPool = QThreadPool::globalInstance(); + QThreadPool *threadPool = QThreadPoolPrivate::qtGuiInstance(); if (segments > 1 && threadPool && !threadPool->contains(QThread::currentThread())) { QSemaphore semaphore; int y = 0; diff --git a/src/gui/painting/qoutlinemapper.cpp b/src/gui/painting/qoutlinemapper.cpp index 0dfb310ee9..2f87ff43b7 100644 --- a/src/gui/painting/qoutlinemapper.cpp +++ b/src/gui/painting/qoutlinemapper.cpp @@ -37,6 +37,24 @@ static const QRectF boundingRect(const QPointF *points, int pointCount) return QRectF(QPointF(minx, miny), QPointF(maxx, maxy)); } +void QOutlineMapper::setClipRect(QRect clipRect) +{ + auto limitCoords = [](QRect r) { + const QRect limitRect(QPoint(-QT_RASTER_COORD_LIMIT, -QT_RASTER_COORD_LIMIT), + QPoint(QT_RASTER_COORD_LIMIT, QT_RASTER_COORD_LIMIT)); + r &= limitRect; + r.setWidth(qMin(r.width(), QT_RASTER_COORD_LIMIT)); + r.setHeight(qMin(r.height(), QT_RASTER_COORD_LIMIT)); + return r; + }; + + if (clipRect != m_clip_rect) { + m_clip_rect = limitCoords(clipRect); + const int mw = 1 << 10; // margin width. No need to trigger clipping for slight overshooting + m_clip_trigger_rect = QRectF(limitCoords(m_clip_rect.adjusted(-mw, -mw, mw, mw))); + } +} + void QOutlineMapper::curveTo(const QPointF &cp1, const QPointF &cp2, const QPointF &ep) { #ifdef QT_DEBUG_CONVERT printf("QOutlineMapper::curveTo() (%f, %f)\n", ep.x(), ep.y()); @@ -200,16 +218,8 @@ void QOutlineMapper::endOutline() m_clip_rect.x(), m_clip_rect.y(), m_clip_rect.width(), m_clip_rect.height()); #endif - - // Check for out of dev bounds... - const bool do_clip = !m_in_clip_elements && ((controlPointRect.left() < -QT_RASTER_COORD_LIMIT - || controlPointRect.right() > QT_RASTER_COORD_LIMIT - || controlPointRect.top() < -QT_RASTER_COORD_LIMIT - || controlPointRect.bottom() > QT_RASTER_COORD_LIMIT - || controlPointRect.width() > QT_RASTER_COORD_LIMIT - || controlPointRect.height() > QT_RASTER_COORD_LIMIT)); - - if (do_clip) { + // Avoid rasterizing outside cliprect: faster, and ensures coords < QT_RASTER_COORD_LIMIT + if (!m_in_clip_elements && !m_clip_trigger_rect.contains(controlPointRect)) { clipElements(elements, elementTypes(), m_elements.size()); } else { convertElements(elements, elementTypes(), m_elements.size()); diff --git a/src/gui/painting/qoutlinemapper_p.h b/src/gui/painting/qoutlinemapper_p.h index 372f9b4ec2..ff2fff6bac 100644 --- a/src/gui/painting/qoutlinemapper_p.h +++ b/src/gui/painting/qoutlinemapper_p.h @@ -45,7 +45,7 @@ Q_GUI_EXPORT bool qt_scaleForTransform(const QTransform &transform, qreal *scale * class QOutlineMapper * * Used to map between QPainterPath and the QT_FT_Outline structure used by the - * freetype scanconvertor. + * freetype scanconverter. * * The outline mapper uses a path iterator to get points from the path, * so that it is possible to transform the points as they are converted. The @@ -79,6 +79,8 @@ public: m_curve_threshold = scale == 0 ? qreal(0.25) : (qreal(0.25) / scale); } + void setClipRect(QRect clipRect); + void beginOutline(Qt::FillRule fillRule) { #ifdef QT_DEBUG_CONVERT @@ -163,6 +165,7 @@ public: QDataBuffer<int> m_contours; QRect m_clip_rect; + QRectF m_clip_trigger_rect; QRectF controlPointRect; // only valid after endOutline() QT_FT_Outline m_outline; diff --git a/src/gui/painting/qpagelayout.cpp b/src/gui/painting/qpagelayout.cpp index 456fcf8802..e60f464d6e 100644 --- a/src/gui/painting/qpagelayout.cpp +++ b/src/gui/painting/qpagelayout.cpp @@ -39,41 +39,19 @@ Q_GUI_EXPORT qreal qt_pointMultiplier(QPageLayout::Unit unit) // Multiplier for converting pixels to points. extern qreal qt_pixelMultiplier(int resolution); -QPointF qt_convertPoint(const QPointF &xy, QPageLayout::Unit fromUnits, QPageLayout::Unit toUnits) -{ - // If the size have the same units, or are all 0, then don't need to convert - if (fromUnits == toUnits || xy.isNull()) - return xy; - - // If converting to points then convert and round to 0 decimal places - if (toUnits == QPageLayout::Point) { - const qreal multiplier = qt_pointMultiplier(fromUnits); - return QPointF(qRound(xy.x() * multiplier), - qRound(xy.y() * multiplier)); - } - - // If converting to other units, need to convert to unrounded points first - QPointF pointXy = (fromUnits == QPageLayout::Point) ? xy : xy * qt_pointMultiplier(fromUnits); - - // Then convert from points to required units rounded to 2 decimal places - const qreal multiplier = qt_pointMultiplier(toUnits); - return QPointF(qRound(pointXy.x() * 100 / multiplier) / 100.0, - qRound(pointXy.y() * 100 / multiplier) / 100.0); -} - Q_GUI_EXPORT QMarginsF qt_convertMargins(const QMarginsF &margins, QPageLayout::Unit fromUnits, QPageLayout::Unit toUnits) { // If the margins have the same units, or are all 0, then don't need to convert if (fromUnits == toUnits || margins.isNull()) return margins; - // If converting to points then convert and round to 0 decimal places + // If converting to points then convert and round up to 2 decimal places if (toUnits == QPageLayout::Point) { - const qreal multiplier = qt_pointMultiplier(fromUnits); - return QMarginsF(qRound(margins.left() * multiplier), - qRound(margins.top() * multiplier), - qRound(margins.right() * multiplier), - qRound(margins.bottom() * multiplier)); + const qreal multiplierX100 = qt_pointMultiplier(fromUnits) * 100; + return QMarginsF(qCeil(margins.left() * multiplierX100) / 100.0, + qCeil(margins.top() * multiplierX100) / 100.0, + qCeil(margins.right() * multiplierX100) / 100.0, + qCeil(margins.bottom() * multiplierX100) / 100.0); } // If converting to other units, need to convert to unrounded points first @@ -101,10 +79,10 @@ public: bool isValid() const; - void clampMargins(const QMarginsF &margins); + QMarginsF clampMargins(const QMarginsF &margins) const; QMarginsF margins(QPageLayout::Unit units) const; - QMargins marginsPoints() const; + QMarginsF marginsPoints() const; QMargins marginsPixels(int resolution) const; void setDefaultMargins(const QMarginsF &minMargins); @@ -173,12 +151,12 @@ bool QPageLayoutPrivate::isValid() const return m_pageSize.isValid(); } -void QPageLayoutPrivate::clampMargins(const QMarginsF &margins) +QMarginsF QPageLayoutPrivate::clampMargins(const QMarginsF &margins) const { - m_margins = QMarginsF(qBound(m_minMargins.left(), margins.left(), m_maxMargins.left()), - qBound(m_minMargins.top(), margins.top(), m_maxMargins.top()), - qBound(m_minMargins.right(), margins.right(), m_maxMargins.right()), - qBound(m_minMargins.bottom(), margins.bottom(), m_maxMargins.bottom())); + return QMarginsF(qBound(m_minMargins.left(), margins.left(), m_maxMargins.left()), + qBound(m_minMargins.top(), margins.top(), m_maxMargins.top()), + qBound(m_minMargins.right(), margins.right(), m_maxMargins.right()), + qBound(m_minMargins.bottom(), margins.bottom(), m_maxMargins.bottom())); } QMarginsF QPageLayoutPrivate::margins(QPageLayout::Unit units) const @@ -186,14 +164,14 @@ QMarginsF QPageLayoutPrivate::margins(QPageLayout::Unit units) const return qt_convertMargins(m_margins, m_units, units); } -QMargins QPageLayoutPrivate::marginsPoints() const +QMarginsF QPageLayoutPrivate::marginsPoints() const { - return qt_convertMargins(m_margins, m_units, QPageLayout::Point).toMargins(); + return qt_convertMargins(m_margins, m_units, QPageLayout::Point); } QMargins QPageLayoutPrivate::marginsPixels(int resolution) const { - return marginsPoints() / qt_pixelMultiplier(resolution); + return QMarginsF(marginsPoints() / qt_pixelMultiplier(resolution)).toMargins(); } void QPageLayoutPrivate::setDefaultMargins(const QMarginsF &minMargins) @@ -204,7 +182,7 @@ void QPageLayoutPrivate::setDefaultMargins(const QMarginsF &minMargins) qMax(m_fullSize.width() - m_minMargins.left(), qreal(0)), qMax(m_fullSize.height() - m_minMargins.top(), qreal(0))); if (m_mode == QPageLayout::StandardMode) - clampMargins(m_margins); + m_margins = clampMargins(m_margins); } QSizeF QPageLayoutPrivate::fullSizeUnits(QPageLayout::Unit units) const @@ -310,6 +288,27 @@ QRectF QPageLayoutPrivate::paintRect() const \value StandardMode Paint Rect includes margins, margins must fall between the minimum and maximum. \value FullPageMode Paint Rect excludes margins, margins can be any value and must be managed manually. + + In StandardMode, when setting margins, use \l{QPageLayout::OutOfBoundsPolicy::}{Clamp} to + automatically clamp the margins to fall between the minimum and maximum + allowed values. + + \sa OutOfBoundsPolicy +*/ + +/*! + \enum QPageLayout::OutOfBoundsPolicy + \since 6.8 + + Defines the policy for margins that are out of bounds + + \value Reject The margins must fall within the minimum and maximum values, + otherwise they will be rejected. + \value Clamp The margins are clamped between the minimum and maximum + values to ensure they are valid. + + \note The policy has no effect in \l{QPageLayout::Mode}{FullPageMode}, + where all margins are accepted. */ /*! @@ -547,39 +546,52 @@ QPageLayout::Unit QPageLayout::units() const } /*! - Sets the page margins of the page layout to \a margins + Sets the page margins of the page layout to \a margins. Returns true if the margins were successfully set. The units used are those currently defined for the layout. To use different units then call setUnits() first. - If in the default StandardMode then all the new margins must fall between the - minimum margins set and the maximum margins allowed by the page size, - otherwise the margins will not be set. - - If in FullPageMode then any margin values will be accepted. + Since Qt 6.8, the optional \a outOfBoundsPolicy can be used to specify how + margins that are out of bounds are handled. \sa margins(), units() */ -bool QPageLayout::setMargins(const QMarginsF &margins) +bool QPageLayout::setMargins(const QMarginsF &margins, OutOfBoundsPolicy outOfBoundsPolicy) { if (d->m_mode == FullPageMode) { - d.detach(); - d->m_margins = margins; + if (margins != d->m_margins) { + d.detach(); + d->m_margins = margins; + } return true; - } else if (margins.left() >= d->m_minMargins.left() - && margins.right() >= d->m_minMargins.right() - && margins.top() >= d->m_minMargins.top() - && margins.bottom() >= d->m_minMargins.bottom() - && margins.left() <= d->m_maxMargins.left() - && margins.right() <= d->m_maxMargins.right() - && margins.top() <= d->m_maxMargins.top() - && margins.bottom() <= d->m_maxMargins.bottom()) { - d.detach(); - d->m_margins = margins; + } + + if (outOfBoundsPolicy == OutOfBoundsPolicy::Clamp) { + const QMarginsF clampedMargins = d->clampMargins(margins); + if (clampedMargins != d->m_margins) { + d.detach(); + d->m_margins = clampedMargins; + } return true; } + + if (margins.left() >= d->m_minMargins.left() + && margins.right() >= d->m_minMargins.right() + && margins.top() >= d->m_minMargins.top() + && margins.bottom() >= d->m_minMargins.bottom() + && margins.left() <= d->m_maxMargins.left() + && margins.right() <= d->m_maxMargins.right() + && margins.top() <= d->m_maxMargins.top() + && margins.bottom() <= d->m_maxMargins.bottom()) { + if (margins != d->m_margins) { + d.detach(); + d->m_margins = margins; + } + return true; + } + return false; } @@ -590,23 +602,27 @@ bool QPageLayout::setMargins(const QMarginsF &margins) The units used are those currently defined for the layout. To use different units call setUnits() first. - If in the default StandardMode then the new margin must fall between the - minimum margin set and the maximum margin allowed by the page size, - otherwise the margin will not be set. - - If in FullPageMode then any margin values will be accepted. + Since Qt 6.8, the optional \a outOfBoundsPolicy can be used to specify how + margins that are out of bounds are handled. \sa setMargins(), margins() */ -bool QPageLayout::setLeftMargin(qreal leftMargin) +bool QPageLayout::setLeftMargin(qreal leftMargin, OutOfBoundsPolicy outOfBoundsPolicy) { + if (d->m_mode == StandardMode && outOfBoundsPolicy == OutOfBoundsPolicy::Clamp) + leftMargin = qBound(d->m_minMargins.left(), leftMargin, d->m_maxMargins.left()); + + if (qFuzzyCompare(leftMargin, d->m_margins.left())) + return true; + if (d->m_mode == FullPageMode || (leftMargin >= d->m_minMargins.left() && leftMargin <= d->m_maxMargins.left())) { d.detach(); d->m_margins.setLeft(leftMargin); return true; } + return false; } @@ -617,23 +633,27 @@ bool QPageLayout::setLeftMargin(qreal leftMargin) The units used are those currently defined for the layout. To use different units call setUnits() first. - If in the default StandardMode then the new margin must fall between the - minimum margin set and the maximum margin allowed by the page size, - otherwise the margin will not be set. - - If in FullPageMode then any margin values will be accepted. + Since Qt 6.8, the optional \a outOfBoundsPolicy can be used to specify how + margins that are out of bounds are handled. \sa setMargins(), margins() */ -bool QPageLayout::setRightMargin(qreal rightMargin) +bool QPageLayout::setRightMargin(qreal rightMargin, OutOfBoundsPolicy outOfBoundsPolicy) { + if (d->m_mode == StandardMode && outOfBoundsPolicy == OutOfBoundsPolicy::Clamp) + rightMargin = qBound(d->m_minMargins.right(), rightMargin, d->m_maxMargins.right()); + + if (qFuzzyCompare(rightMargin, d->m_margins.right())) + return true; + if (d->m_mode == FullPageMode || (rightMargin >= d->m_minMargins.right() && rightMargin <= d->m_maxMargins.right())) { d.detach(); d->m_margins.setRight(rightMargin); return true; } + return false; } @@ -644,23 +664,27 @@ bool QPageLayout::setRightMargin(qreal rightMargin) The units used are those currently defined for the layout. To use different units call setUnits() first. - If in the default StandardMode then the new margin must fall between the - minimum margin set and the maximum margin allowed by the page size, - otherwise the margin will not be set. - - If in FullPageMode then any margin values will be accepted. + Since Qt 6.8, the optional \a outOfBoundsPolicy can be used to specify how + margins that are out of bounds are handled. \sa setMargins(), margins() */ -bool QPageLayout::setTopMargin(qreal topMargin) +bool QPageLayout::setTopMargin(qreal topMargin, OutOfBoundsPolicy outOfBoundsPolicy) { + if (d->m_mode == StandardMode && outOfBoundsPolicy == OutOfBoundsPolicy::Clamp) + topMargin = qBound(d->m_minMargins.top(), topMargin, d->m_maxMargins.top()); + + if (qFuzzyCompare(topMargin, d->m_margins.top())) + return true; + if (d->m_mode == FullPageMode || (topMargin >= d->m_minMargins.top() && topMargin <= d->m_maxMargins.top())) { d.detach(); d->m_margins.setTop(topMargin); return true; } + return false; } @@ -671,23 +695,27 @@ bool QPageLayout::setTopMargin(qreal topMargin) The units used are those currently defined for the layout. To use different units call setUnits() first. - If in the default StandardMode then the new margin must fall between the - minimum margin set and the maximum margin allowed by the page size, - otherwise the margin will not be set. - - If in FullPageMode then any margin values will be accepted. + Since Qt 6.8, the optional \a outOfBoundsPolicy can be used to specify how + margins that are out of bounds are handled. \sa setMargins(), margins() */ -bool QPageLayout::setBottomMargin(qreal bottomMargin) +bool QPageLayout::setBottomMargin(qreal bottomMargin, OutOfBoundsPolicy outOfBoundsPolicy) { + if (d->m_mode == StandardMode && outOfBoundsPolicy == OutOfBoundsPolicy::Clamp) + bottomMargin = qBound(d->m_minMargins.bottom(), bottomMargin, d->m_maxMargins.bottom()); + + if (qFuzzyCompare(bottomMargin, d->m_margins.bottom())) + return true; + if (d->m_mode == FullPageMode || (bottomMargin >= d->m_minMargins.bottom() && bottomMargin <= d->m_maxMargins.bottom())) { d.detach(); d->m_margins.setBottom(bottomMargin); return true; } + return false; } @@ -721,7 +749,7 @@ QMarginsF QPageLayout::margins(Unit units) const QMargins QPageLayout::marginsPoints() const { - return d->marginsPoints(); + return d->marginsPoints().toMargins(); } /*! @@ -888,7 +916,7 @@ QRect QPageLayout::paintRectPoints() const if (!isValid()) return QRect(); return d->m_mode == FullPageMode ? d->fullRectPoints() - : d->fullRectPoints() - d->marginsPoints(); + : d->fullRectPoints() - d->marginsPoints().toMargins(); } /*! diff --git a/src/gui/painting/qpagelayout.h b/src/gui/painting/qpagelayout.h index 04f58bd403..1e340b6d75 100644 --- a/src/gui/painting/qpagelayout.h +++ b/src/gui/painting/qpagelayout.h @@ -5,7 +5,7 @@ #define QPAGELAYOUT_H #include <QtGui/qtguiglobal.h> -#include <QtCore/qsharedpointer.h> +#include <QtCore/qshareddata.h> #include <QtCore/qstring.h> #include <QtCore/qmargins.h> @@ -40,6 +40,11 @@ public: FullPageMode // Paint Rect excludes margins }; + enum class OutOfBoundsPolicy { + Reject, + Clamp + }; + QPageLayout(); QPageLayout(const QPageSize &pageSize, Orientation orientation, const QMarginsF &margins, Unit units = Point, @@ -68,11 +73,19 @@ public: void setUnits(Unit units); Unit units() const; +#if QT_GUI_REMOVED_SINCE(6, 8) bool setMargins(const QMarginsF &margins); bool setLeftMargin(qreal leftMargin); bool setRightMargin(qreal rightMargin); bool setTopMargin(qreal topMargin); bool setBottomMargin(qreal bottomMargin); +#endif + + bool setMargins(const QMarginsF &margins, OutOfBoundsPolicy outOfBoundsPolicy = OutOfBoundsPolicy::Reject); + bool setLeftMargin(qreal leftMargin, OutOfBoundsPolicy outOfBoundsPolicy = OutOfBoundsPolicy::Reject); + bool setRightMargin(qreal rightMargin, OutOfBoundsPolicy outOfBoundsPolicy = OutOfBoundsPolicy::Reject); + bool setTopMargin(qreal topMargin, OutOfBoundsPolicy outOfBoundsPolicy = OutOfBoundsPolicy::Reject); + bool setBottomMargin(qreal bottomMargin, OutOfBoundsPolicy outOfBoundsPolicy = OutOfBoundsPolicy::Reject); QMarginsF margins() const; QMarginsF margins(Unit units) const; diff --git a/src/gui/painting/qpageranges.cpp b/src/gui/painting/qpageranges.cpp index 7d62c7c321..99a0009883 100644 --- a/src/gui/painting/qpageranges.cpp +++ b/src/gui/painting/qpageranges.cpp @@ -14,7 +14,7 @@ QT_IMPL_METATYPE_EXTERN(QPageRanges) void QPageRangesPrivate::mergeIntervals() { - const int count = intervals.count(); + const int count = intervals.size(); if (count <= 1) return; @@ -162,7 +162,7 @@ QPageRanges QPageRanges::fromString(const QString &ranges) if (item.contains(u'-')) { const QStringList rangeItems = item.split(u'-'); - if (rangeItems.count() != 2) + if (rangeItems.size() != 2) return QPageRanges(); bool ok; @@ -255,7 +255,7 @@ int QPageRanges::firstPage() const { if (isEmpty()) return 0; - return d->intervals.first().from; + return d->intervals.constFirst().from; } /*! @@ -266,7 +266,7 @@ int QPageRanges::lastPage() const { if (isEmpty()) return 0; - return d->intervals.last().to; + return d->intervals.constLast().to; } /*! diff --git a/src/gui/painting/qpagesize.cpp b/src/gui/painting/qpagesize.cpp index 3ed633bf99..37f66fe63d 100644 --- a/src/gui/painting/qpagesize.cpp +++ b/src/gui/painting/qpagesize.cpp @@ -543,7 +543,7 @@ static QSize qt_convertPointsToPixels(const QSize &size, int resolution) if (!size.isValid() || resolution <= 0) return QSize(); const qreal multiplier = qt_pixelMultiplier(resolution); - return QSize(qRound(size.width() / multiplier), qRound(size.height() / multiplier)); + return QSize(qFloor(size.width() / multiplier), qFloor(size.height() / multiplier)); } static QSizeF qt_convertPointsToUnits(const QSize &size, QPageSize::Unit units) @@ -869,7 +869,7 @@ QSizeF QPageSizePrivate::size(QPageSize::Unit units) const QSize QPageSizePrivate::sizePixels(int resolution) const { - return qt_convertPointsToPixels(m_pointSize, resolution);; + return qt_convertPointsToPixels(m_pointSize, resolution); } diff --git a/src/gui/painting/qpaintengine.cpp b/src/gui/painting/qpaintengine.cpp index 839be3bd41..aface3744d 100644 --- a/src/gui/painting/qpaintengine.cpp +++ b/src/gui/painting/qpaintengine.cpp @@ -481,6 +481,8 @@ void QPaintEngine::drawEllipse(const QRectF &rect) } /*! + \overload + The default implementation of this function calls the floating point version of this function */ diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp index a5acd6a324..f62373d4ef 100644 --- a/src/gui/painting/qpaintengine_raster.cpp +++ b/src/gui/painting/qpaintengine_raster.cpp @@ -98,7 +98,6 @@ public: Q_GUI_EXPORT extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale); // qtransform.cpp -#define qreal_to_fixed_26_6(f) (int(f * 64)) #define qt_swap_int(x, y) { int tmp = (x); (x) = (y); (y) = tmp; } #define qt_swap_qreal(x, y) { qreal tmp = (x); (x) = (y); (y) = tmp; } @@ -144,9 +143,9 @@ bool QRasterPaintEngine::clearTypeFontsEnabled() /******************************************************************************** * Span functions */ -static void qt_span_fill_clipRect(int count, const QSpan *spans, void *userData); -static void qt_span_fill_clipped(int count, const QSpan *spans, void *userData); -static void qt_span_clip(int count, const QSpan *spans, void *userData); +static void qt_span_fill_clipRect(int count, const QT_FT_Span *spans, void *userData); +static void qt_span_fill_clipped(int count, const QT_FT_Span *spans, void *userData); +static void qt_span_clip(int count, const QT_FT_Span *spans, void *userData); struct ClipData { @@ -241,8 +240,7 @@ QRasterPaintEnginePrivate::QRasterPaintEnginePrivate() : /*! \class QRasterPaintEngine - \preliminary - \ingroup qws + \internal \inmodule QtGui \since 4.2 @@ -277,15 +275,6 @@ QRasterPaintEnginePrivate::QRasterPaintEnginePrivate() : */ /*! - \typedef QSpan - \relates QRasterPaintEngine - - A struct equivalent to QT_FT_Span, containing a position (x, - y), the span's length in pixels and its color/coverage (a value - ranging from 0 to 255). -*/ - -/*! \since 4.5 Creates a raster based paint engine for operating on the given @@ -416,22 +405,16 @@ bool QRasterPaintEngine::begin(QPaintDevice *device) QRasterPaintEngineState *s = state(); ensureOutlineMapper(); - d->outlineMapper->m_clip_rect = d->deviceRect; - - if (d->outlineMapper->m_clip_rect.width() > QT_RASTER_COORD_LIMIT) - d->outlineMapper->m_clip_rect.setWidth(QT_RASTER_COORD_LIMIT); - if (d->outlineMapper->m_clip_rect.height() > QT_RASTER_COORD_LIMIT) - d->outlineMapper->m_clip_rect.setHeight(QT_RASTER_COORD_LIMIT); - + d->outlineMapper->setClipRect(d->deviceRect); d->rasterizer->setClipRect(d->deviceRect); s->penData.init(d->rasterBuffer.data(), this); - s->penData.setup(s->pen.brush(), s->intOpacity, s->composition_mode); + s->penData.setup(s->pen.brush(), s->intOpacity, s->composition_mode, s->flags.cosmetic_brush); s->stroker = &d->basicStroker; d->basicStroker.setClipRect(d->deviceRect); s->brushData.init(d->rasterBuffer.data(), this); - s->brushData.setup(s->brush, s->intOpacity, s->composition_mode); + s->brushData.setup(s->brush, s->intOpacity, s->composition_mode, s->flags.cosmetic_brush); d->rasterBuffer->compositionMode = QPainter::CompositionMode_SourceOver; @@ -516,6 +499,7 @@ QRasterPaintEngineState::QRasterPaintEngineState() txscale = 1.; + flag_bits = 0; flags.fast_pen = true; flags.non_complex_pen = false; flags.antialiased = false; @@ -523,6 +507,7 @@ QRasterPaintEngineState::QRasterPaintEngineState() flags.fast_text = true; flags.tx_noshear = true; flags.fast_images = true; + flags.cosmetic_brush = true; clip = nullptr; flags.has_clip_ownership = false; @@ -621,7 +606,8 @@ void QRasterPaintEngine::updatePen(const QPen &pen) s->strokeFlags = 0; s->penData.clip = d->clip(); - s->penData.setup(pen_style == Qt::NoPen ? QBrush() : pen.brush(), s->intOpacity, s->composition_mode); + s->penData.setup(pen_style == Qt::NoPen ? QBrush() : pen.brush(), s->intOpacity, + s->composition_mode, s->flags.cosmetic_brush); if (s->strokeFlags & QRasterPaintEngine::DirtyTransform || pen.brush().transform().type() >= QTransform::TxNone) { @@ -720,7 +706,7 @@ void QRasterPaintEngine::updateBrush(const QBrush &brush) QRasterPaintEngineState *s = state(); // must set clip prior to setup, as setup uses it... s->brushData.clip = d->clip(); - s->brushData.setup(brush, s->intOpacity, s->composition_mode); + s->brushData.setup(brush, s->intOpacity, s->composition_mode, s->flags.cosmetic_brush); if (s->fillFlags & DirtyTransform || brush.transform().type() >= QTransform::TxNone) d_func()->updateMatrixData(&s->brushData, brush, d->brushMatrix()); @@ -807,14 +793,16 @@ void QRasterPaintEngine::renderHintsChanged() bool was_aa = s->flags.antialiased; bool was_bilinear = s->flags.bilinear; + bool was_cosmetic_brush = s->flags.cosmetic_brush; s->flags.antialiased = bool(s->renderHints & QPainter::Antialiasing); s->flags.bilinear = bool(s->renderHints & QPainter::SmoothPixmapTransform); + s->flags.cosmetic_brush = !bool(s->renderHints & QPainter::NonCosmeticBrushPatterns); if (was_aa != s->flags.antialiased) s->strokeFlags |= DirtyHints; - if (was_bilinear != s->flags.bilinear) { + if (was_bilinear != s->flags.bilinear || was_cosmetic_brush != s->flags.cosmetic_brush) { s->strokeFlags |= DirtyPen; s->fillFlags |= DirtyBrush; } @@ -2273,6 +2261,7 @@ void QRasterPaintEngine::drawImage(const QRectF &r, const QImage &img, const QRe || d->rasterBuffer->compositionMode == QPainter::CompositionMode_Source)) { RotationType rotationType = qRotationType(s->matrix); + Q_ASSERT(d->rasterBuffer->format < QImage::NImageFormats); const QPixelLayout::BPP plBpp = qPixelLayouts[d->rasterBuffer->format].bpp; if (rotationType != NoRotation && qMemRotateFunctions[plBpp][rotationType] && img.rect().contains(sr.toAlignedRect())) { @@ -2353,9 +2342,16 @@ void QRasterPaintEngine::drawImage(const QRectF &r, const QImage &img, const QRe } SrcOverScaleFunc func = qScaleFunctions[d->rasterBuffer->format][img.format()]; if (func && (!clip || clip->hasRectClip)) { + QRectF tr = qt_mapRect_non_normalizing(r, s->matrix); + if (!s->flags.antialiased) { + tr.setX(qRound(tr.x())); + tr.setY(qRound(tr.y())); + tr.setWidth(qRound(tr.width())); + tr.setHeight(qRound(tr.height())); + } func(d->rasterBuffer->buffer(), d->rasterBuffer->bytesPerLine(), img.bits(), img.bytesPerLine(), img.height(), - qt_mapRect_non_normalizing(r, s->matrix), sr, + tr, sr, !clip ? d->deviceRect : clip->clipRect, s->intOpacity); return; @@ -2665,7 +2661,7 @@ void QRasterPaintEngine::alphaPenBlt(const void* src, int bpl, int depth, int rx return; const int NSPANS = 512; - QSpan spans[NSPANS]; + QT_FT_Span spans[NSPANS]; int current = 0; const int x1 = x0 + w; @@ -3003,8 +2999,14 @@ QRasterPaintEnginePrivate::getPenFunc(const QRectF &rect, return isUnclipped(rect, penWidth) ? data->unclipped_blend : data->blend; } -static QPair<int, int> visibleGlyphRange(const QRectF &clip, QFontEngine *fontEngine, - glyph_t *glyphs, QFixedPoint *positions, int numGlyphs) +struct VisibleGlyphRange +{ + int begin; + int end; +}; + +static VisibleGlyphRange visibleGlyphRange(const QRectF &clip, QFontEngine *fontEngine, + glyph_t *glyphs, QFixedPoint *positions, int numGlyphs) { QFixed clipLeft = QFixed::fromReal(clip.left() - 1); QFixed clipRight = QFixed::fromReal(clip.right() + 1); @@ -3033,7 +3035,7 @@ static QPair<int, int> visibleGlyphRange(const QRectF &clip, QFontEngine *fontEn break; --last; } - return QPair<int, int>(first, last + 1); + return {first, last + 1}; } /*! @@ -3059,13 +3061,13 @@ void QRasterPaintEngine::drawStaticTextItem(QStaticTextItem *textItem) if (!invertible) return; - QPair<int, int> range = visibleGlyphRange(invMat.mapRect(clipBoundingRect()), - textItem->fontEngine(), textItem->glyphs, - textItem->glyphPositions, textItem->numGlyphs); + const auto range = visibleGlyphRange(invMat.mapRect(clipBoundingRect()), + textItem->fontEngine(), textItem->glyphs, + textItem->glyphPositions, textItem->numGlyphs); QStaticTextItem copy = *textItem; - copy.glyphs += range.first; - copy.glyphPositions += range.first; - copy.numGlyphs = range.second - range.first; + copy.glyphs += range.begin; + copy.glyphPositions += range.begin; + copy.numGlyphs = range.end - range.begin; QPaintEngineEx::drawStaticTextItem(©); } else { QPaintEngineEx::drawStaticTextItem(textItem); @@ -3114,20 +3116,20 @@ void QRasterPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textIte ti.fontEngine->getGlyphPositions(ti.glyphs, QTransform::fromTranslate(p.x(), p.y()), ti.flags, glyphs, positions); - QPair<int, int> range = visibleGlyphRange(invMat.mapRect(clipBoundingRect()), - ti.fontEngine, glyphs.data(), positions.data(), - glyphs.size()); + const auto range = visibleGlyphRange(invMat.mapRect(clipBoundingRect()), + ti.fontEngine, glyphs.data(), positions.data(), + glyphs.size()); - if (range.first >= range.second) + if (range.begin >= range.end) return; QStaticTextItem staticTextItem; staticTextItem.color = s->pen.color(); staticTextItem.font = s->font; staticTextItem.setFontEngine(ti.fontEngine); - staticTextItem.numGlyphs = range.second - range.first; - staticTextItem.glyphs = glyphs.data() + range.first; - staticTextItem.glyphPositions = positions.data() + range.first; + staticTextItem.numGlyphs = range.end - range.begin; + staticTextItem.glyphs = glyphs.data() + range.begin; + staticTextItem.glyphPositions = positions.data() + range.begin; QPaintEngineEx::drawStaticTextItem(&staticTextItem); } else { QPaintEngineEx::drawTextItem(p, ti); @@ -3395,16 +3397,18 @@ void QRasterPaintEngine::drawBitmap(const QPointF &pos, const QImage &image, QSp // Boundaries int w = image.width(); int h = image.height(); - int ymax = qMin(qRound(pos.y() + h), d->rasterBuffer->height()); - int ymin = qMax(qRound(pos.y()), 0); - int xmax = qMin(qRound(pos.x() + w), d->rasterBuffer->width()); - int xmin = qMax(qRound(pos.x()), 0); + int px = qRound(pos.x()); + int py = qRound(pos.y()); + int ymax = qMin(py + h, d->rasterBuffer->height()); + int ymin = qMax(py, 0); + int xmax = qMin(px + w, d->rasterBuffer->width()); + int xmin = qMax(px, 0); - int x_offset = xmin - qRound(pos.x()); + int x_offset = xmin - px; QImage::Format format = image.format(); for (int y = ymin; y < ymax; ++y) { - const uchar *src = image.scanLine(y - qRound(pos.y())); + const uchar *src = image.scanLine(y - py); if (format == QImage::Format_MonoLSB) { for (int x = 0; x < xmax - xmin; ++x) { int src_x = x + x_offset; @@ -3709,15 +3713,9 @@ bool QRasterPaintEnginePrivate::canUseImageBlitting(QPainter::CompositionMode mo QImage::Format dFormat = rasterBuffer->format; QImage::Format sFormat = image.format(); - // Formats must match or source format must be a subset of destination format - if (dFormat != sFormat && image.pixelFormat().alphaUsage() == QPixelFormat::IgnoresAlpha) { - if ((sFormat == QImage::Format_RGB32 && dFormat == QImage::Format_ARGB32) - || (sFormat == QImage::Format_RGBX8888 && dFormat == QImage::Format_RGBA8888) - || (sFormat == QImage::Format_RGBX64 && dFormat == QImage::Format_RGBA64)) - sFormat = dFormat; - else - sFormat = qt_maybeAlphaVersionWithSameDepth(sFormat); // this returns premul formats - } + // Formats must match or source format must be an opaque version of destination format + if (dFormat != sFormat && image.pixelFormat().alphaUsage() == QPixelFormat::IgnoresAlpha) + dFormat = qt_maybeDataCompatibleOpaqueVersion(dFormat); return (dFormat == sFormat); } @@ -3804,7 +3802,7 @@ void QClipData::initialize() return; if (!m_clipLines) - m_clipLines = (ClipLine *)calloc(sizeof(ClipLine), clipSpanHeight); + m_clipLines = (ClipLine *)calloc(clipSpanHeight, sizeof(ClipLine)); Q_CHECK_PTR(m_clipLines); QT_TRY { @@ -3816,7 +3814,7 @@ void QClipData::initialize() const int numRects = clipRegion.rectCount(); const int maxSpans = (ymax - ymin) * numRects; allocated = qMax(allocated, maxSpans); - m_spans = (QSpan *)malloc(allocated * sizeof(QSpan)); + m_spans = (QT_FT_Span *)malloc(allocated * sizeof(QT_FT_Span)); Q_CHECK_PTR(m_spans); int y = 0; @@ -3842,7 +3840,7 @@ void QClipData::initialize() for (int r = firstInBand; r <= lastInBand; ++r) { const QRect &currRect = rects[r]; - QSpan *span = m_spans + count; + QT_FT_Span *span = m_spans + count; span->x = currRect.x(); span->len = currRect.width(); span->y = y; @@ -3866,7 +3864,7 @@ void QClipData::initialize() return; } - m_spans = (QSpan *)malloc(allocated * sizeof(QSpan)); + m_spans = (QT_FT_Span *)malloc(allocated * sizeof(QT_FT_Span)); Q_CHECK_PTR(m_spans); if (hasRectClip) { @@ -3879,7 +3877,7 @@ void QClipData::initialize() const int len = clipRect.width(); while (y < ymax) { - QSpan *span = m_spans + count; + QT_FT_Span *span = m_spans + count; span->x = xmin; span->len = len; span->y = y; @@ -4018,16 +4016,16 @@ void QClipData::setClipRegion(const QRegion ®ion) \internal spans must be sorted on y */ -static const QSpan *qt_intersect_spans(const QClipData *clip, int *currentClip, - const QSpan *spans, const QSpan *end, - QSpan **outSpans, int available) +static const QT_FT_Span *qt_intersect_spans(const QClipData *clip, int *currentClip, + const QT_FT_Span *spans, const QT_FT_Span *end, + QT_FT_Span **outSpans, int available) { const_cast<QClipData *>(clip)->initialize(); - QSpan *out = *outSpans; + QT_FT_Span *out = *outSpans; - const QSpan *clipSpans = clip->m_spans + *currentClip; - const QSpan *clipEnd = clip->m_spans + clip->count; + const QT_FT_Span *clipSpans = clip->m_spans + *currentClip; + const QT_FT_Span *clipEnd = clip->m_spans + clip->count; while (available && spans < end ) { if (clipSpans >= clipEnd) { @@ -4081,7 +4079,7 @@ static const QSpan *qt_intersect_spans(const QClipData *clip, int *currentClip, return spans; } -static void qt_span_fill_clipped(int spanCount, const QSpan *spans, void *userData) +static void qt_span_fill_clipped(int spanCount, const QT_FT_Span *spans, void *userData) { // qDebug() << "qt_span_fill_clipped" << spanCount; QSpanData *fillData = reinterpret_cast<QSpanData *>(userData); @@ -4089,11 +4087,11 @@ static void qt_span_fill_clipped(int spanCount, const QSpan *spans, void *userDa Q_ASSERT(fillData->blend && fillData->unclipped_blend); const int NSPANS = 512; - QSpan cspans[NSPANS]; + QT_FT_Span cspans[NSPANS]; int currentClip = 0; - const QSpan *end = spans + spanCount; + const QT_FT_Span *end = spans + spanCount; while (spans < end) { - QSpan *clipped = cspans; + QT_FT_Span *clipped = cspans; spans = qt_intersect_spans(fillData->clip, ¤tClip, spans, end, &clipped, NSPANS); // qDebug() << "processed " << spanCount - (end - spans) << "clipped" << clipped-cspans // << "span:" << cspans->x << cspans->y << cspans->len << spans->coverage; @@ -4145,7 +4143,7 @@ static int qt_intersect_spans(QT_FT_Span *&spans, int numSpans, } -static void qt_span_fill_clipRect(int count, const QSpan *spans, +static void qt_span_fill_clipRect(int count, const QT_FT_Span *spans, void *userData) { QSpanData *fillData = reinterpret_cast<QSpanData *>(userData); @@ -4154,7 +4152,7 @@ static void qt_span_fill_clipRect(int count, const QSpan *spans, Q_ASSERT(fillData->clip); Q_ASSERT(!fillData->clip->clipRect.isEmpty()); - QSpan *s = const_cast<QSpan *>(spans); + QT_FT_Span *s = const_cast<QT_FT_Span *>(spans); // hw: check if this const_cast<> is safe!!! count = qt_intersect_spans(s, count, fillData->clip->clipRect); @@ -4162,7 +4160,7 @@ static void qt_span_fill_clipRect(int count, const QSpan *spans, fillData->unclipped_blend(count, s, fillData); } -static void qt_span_clip(int count, const QSpan *spans, void *userData) +static void qt_span_clip(int count, const QT_FT_Span *spans, void *userData) { ClipData *clipData = reinterpret_cast<ClipData *>(userData); @@ -4179,14 +4177,14 @@ static void qt_span_clip(int count, const QSpan *spans, void *userData) newClip->initialize(); int currentClip = 0; - const QSpan *end = spans + count; + const QT_FT_Span *end = spans + count; while (spans < end) { - QSpan *newspans = newClip->m_spans + newClip->count; + QT_FT_Span *newspans = newClip->m_spans + newClip->count; spans = qt_intersect_spans(clipData->oldClip, ¤tClip, spans, end, &newspans, newClip->allocated - newClip->count); newClip->count = newspans - newClip->m_spans; if (spans < end) { - newClip->m_spans = q_check_ptr((QSpan *)realloc(newClip->m_spans, newClip->allocated*2*sizeof(QSpan))); + newClip->m_spans = q_check_ptr((QT_FT_Span *)realloc(newClip->m_spans, newClip->allocated * 2 * sizeof(QT_FT_Span))); newClip->allocated *= 2; } } @@ -4204,7 +4202,7 @@ static void qt_span_clip(int count, const QSpan *spans, void *userData) class QGradientCache { public: - struct CacheInfo : QSpanData::Pinnable + struct CacheInfo { inline CacheInfo(QGradientStops s, int op, QGradient::InterpolationMode mode) : stops(std::move(s)), opacity(op), interpolationMode(mode) {} @@ -4215,9 +4213,9 @@ public: QGradient::InterpolationMode interpolationMode; }; - typedef QMultiHash<quint64, QSharedPointer<const CacheInfo>> QGradientColorTableHash; + using QGradientColorTableHash = QMultiHash<quint64, std::shared_ptr<const CacheInfo>>; - inline QSharedPointer<const CacheInfo> getBuffer(const QGradient &gradient, int opacity) { + std::shared_ptr<const CacheInfo> getBuffer(const QGradient &gradient, int opacity) { quint64 hash_val = 0; const QGradientStops stops = gradient.stops(); @@ -4247,16 +4245,16 @@ protected: inline void generateGradientColorTable(const QGradient& g, QRgba64 *colorTable, int size, int opacity) const; - QSharedPointer<const CacheInfo> addCacheElement(quint64 hash_val, const QGradient &gradient, int opacity) { + std::shared_ptr<const CacheInfo> addCacheElement(quint64 hash_val, const QGradient &gradient, int opacity) { if (cache.size() == maxCacheSize()) { // may remove more than 1, but OK cache.erase(std::next(cache.begin(), QRandomGenerator::global()->bounded(maxCacheSize()))); } - auto cache_entry = QSharedPointer<CacheInfo>::create(gradient.stops(), opacity, gradient.interpolationMode()); + auto cache_entry = std::make_shared<CacheInfo>(gradient.stops(), opacity, gradient.interpolationMode()); generateGradientColorTable(gradient, cache_entry->buffer64, paletteSize(), opacity); for (int i = 0; i < GRADIENT_STOPTABLE_SIZE; ++i) cache_entry->buffer32[i] = cache_entry->buffer64[i].toArgb32(); - return cache.insert(hash_val, cache_entry).value(); + return cache.insert(hash_val, std::move(cache_entry)).value(); } QGradientColorTableHash cache; @@ -4266,7 +4264,7 @@ protected: void QGradientCache::generateGradientColorTable(const QGradient& gradient, QRgba64 *colorTable, int size, int opacity) const { const QGradientStops stops = gradient.stops(); - int stopCount = stops.count(); + int stopCount = stops.size(); Q_ASSERT(stopCount > 0); bool colorInterpolation = (gradient.interpolationMode() == QGradient::ColorInterpolation); @@ -4472,7 +4470,8 @@ void QSpanData::init(QRasterBuffer *rb, const QRasterPaintEngine *pe) Q_GUI_EXPORT extern QImage qt_imageForBrush(int brushStyle, bool invert); -void QSpanData::setup(const QBrush &brush, int alpha, QPainter::CompositionMode compositionMode) +void QSpanData::setup(const QBrush &brush, int alpha, QPainter::CompositionMode compositionMode, + bool isCosmetic) { Qt::BrushStyle brushStyle = qbrush_style(brush); cachedGradient.reset(); @@ -4579,7 +4578,7 @@ void QSpanData::setup(const QBrush &brush, int alpha, QPainter::CompositionMode if (!tempImage) tempImage = new QImage(); *tempImage = rasterBuffer->colorizeBitmap(qt_imageForBrush(brushStyle, true), brush.color()); - initTexture(tempImage, alpha, QTextureData::Pattern); + initTexture(tempImage, alpha, isCosmetic ? QTextureData::Pattern : QTextureData::Tiled); break; case Qt::TexturePattern: type = Texture; @@ -4866,7 +4865,7 @@ void dumpClip(int width, int height, const QClipData *clip) ((QClipData *) clip)->spans(); // Force allocation of the spans structure... for (int i = 0; i < clip->count; ++i) { - const QSpan *span = ((QClipData *) clip)->spans() + i; + const QT_FT_Span *span = ((QClipData *) clip)->spans() + i; for (int j = 0; j < span->len; ++j) clipImg.setPixel(span->x + j, span->y, 0xffffff00); x0 = qMin(x0, int(span->x)); diff --git a/src/gui/painting/qpaintengine_raster_p.h b/src/gui/painting/qpaintengine_raster_p.h index abd1a16ade..ab0048af52 100644 --- a/src/gui/painting/qpaintengine_raster_p.h +++ b/src/gui/painting/qpaintengine_raster_p.h @@ -76,6 +76,7 @@ public: uint fast_text : 1; uint tx_noshear : 1; uint fast_images : 1; + uint cosmetic_brush : 1; }; union { @@ -314,7 +315,7 @@ public: int clipSpanHeight; struct ClipLine { int count; - QSpan *spans; + QT_FT_Span *spans; } *m_clipLines; void initialize(); @@ -325,7 +326,7 @@ public: return m_clipLines; } - inline QSpan *spans() { + inline QT_FT_Span *spans() { if (!m_spans) initialize(); return m_spans; @@ -333,7 +334,7 @@ public: int allocated; int count; - QSpan *m_spans; + QT_FT_Span *m_spans; int xmin, xmax, ymin, ymax; QRect clipRect; @@ -344,7 +345,7 @@ public: uint hasRegionClip : 1; void appendSpan(int x, int length, int y, int coverage); - void appendSpans(const QSpan *s, int num); + void appendSpans(const QT_FT_Span *s, int num); // ### Should optimize and actually kill the QSpans if the rect is // ### a subset of The current region. Thus the "fast" clipspan @@ -360,7 +361,7 @@ inline void QClipData::appendSpan(int x, int length, int y, int coverage) if (count == allocated) { allocated *= 2; - m_spans = (QSpan *)realloc(m_spans, allocated*sizeof(QSpan)); + m_spans = (QT_FT_Span *)realloc(m_spans, allocated*sizeof(QT_FT_Span)); } m_spans[count].x = x; m_spans[count].len = length; @@ -369,7 +370,7 @@ inline void QClipData::appendSpan(int x, int length, int y, int coverage) ++count; } -inline void QClipData::appendSpans(const QSpan *s, int num) +inline void QClipData::appendSpans(const QT_FT_Span *s, int num) { Q_ASSERT(m_spans); @@ -377,9 +378,9 @@ inline void QClipData::appendSpans(const QSpan *s, int num) do { allocated *= 2; } while (count + num > allocated); - m_spans = (QSpan *)realloc(m_spans, allocated*sizeof(QSpan)); + m_spans = (QT_FT_Span *)realloc(m_spans, allocated*sizeof(QT_FT_Span)); } - memcpy(m_spans+count, s, num*sizeof(QSpan)); + memcpy(m_spans+count, s, num*sizeof(QT_FT_Span)); count += num; } diff --git a/src/gui/painting/qpaintengineex.cpp b/src/gui/painting/qpaintengineex.cpp index 7f1c7e356d..9468876c23 100644 --- a/src/gui/painting/qpaintengineex.cpp +++ b/src/gui/painting/qpaintengineex.cpp @@ -902,7 +902,7 @@ void QPaintEngineEx::drawPoints(const QPoint *points, int pointCount) void QPaintEngineEx::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode) { - Q_ASSUME(pointCount >= 2); + Q_ASSERT(pointCount >= 2); QVectorPath path((const qreal *) points, pointCount, nullptr, QVectorPath::polygonFlags(mode)); if (mode == PolylineMode) @@ -913,7 +913,7 @@ void QPaintEngineEx::drawPolygon(const QPointF *points, int pointCount, PolygonD void QPaintEngineEx::drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode) { - Q_ASSUME(pointCount >= 2); + Q_ASSERT(pointCount >= 2); int count = pointCount<<1; QVarLengthArray<qreal> pts(count); diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp index a38d42c504..f4b9741eed 100644 --- a/src/gui/painting/qpainter.cpp +++ b/src/gui/painting/qpainter.cpp @@ -39,6 +39,7 @@ #include <private/qhexstring_p.h> #include <private/qguiapplication_p.h> #include <private/qrawfont_p.h> +#include <private/qfont_p.h> QT_BEGIN_NAMESPACE @@ -220,7 +221,7 @@ qreal QPainterPrivate::effectiveDevicePixelRatio() const if (device->devType() == QInternal::Printer) return qreal(1); - return qMax(qreal(1), device->devicePixelRatio()); + return device->devicePixelRatio(); } QTransform QPainterPrivate::hidpiScaleTransform() const @@ -380,7 +381,7 @@ void QPainterPrivate::draw_helper(const QPainterPath &originalPath, DrawOperatio if (q->hasClipping()) { bool hasPerspectiveTransform = false; - for (const QPainterClipInfo &info : qAsConst(state->clipInfo)) { + for (const QPainterClipInfo &info : std::as_const(state->clipInfo)) { if (info.matrix.type() == QTransform::TxProject) { hasPerspectiveTransform = true; break; @@ -1124,24 +1125,22 @@ void QPainterPrivate::updateState(QPainterState *newState) The QPainter class also provides a means of controlling the rendering quality through its RenderHint enum and the support for floating point precision: All the functions for drawing primitives - has a floating point version. These are often used in combination + have floating point versions. + + \snippet code/src_gui_painting_qpainter.cpp floatBased + + These are often used in combination with the \l {RenderHint}{QPainter::Antialiasing} render hint. + \snippet code/src_gui_painting_qpainter.cpp renderHint + \table 100% \row + \li Comparing concentric circles with int and float, and with or without + anti-aliased rendering. Using the floating point precision versions + produces evenly spaced rings. Anti-aliased rendering results in + smooth circles. \li \inlineimage qpainter-concentriccircles.png - \li - \b {Concentric Circles Example} - - The \l {painting/concentriccircles}{Concentric Circles} example - shows the improved rendering quality that can be obtained using - floating point precision and anti-aliasing when drawing custom - widgets. - - The application's main window displays several widgets which are - drawn using the various combinations of precision and - anti-aliasing. - \endtable The RenderHint enum specifies flags to QPainter that may or may @@ -1412,8 +1411,14 @@ void QPainterPrivate::updateState(QPainterState *newState) JPEG compression. This value was added in Qt 5.13. + \value NonCosmeticBrushPatterns When painting with a brush with one of the predefined pattern + styles, transform the pattern too, along with the object being painted. The default is to treat + the pattern as cosmetic, so that the pattern pixels will map directly to device pixels, + independently of any active transformations. + This value was added in Qt 6.4. + \sa renderHints(), setRenderHint(), {QPainter#Rendering - Quality}{Rendering Quality}, {Concentric Circles Example} + Quality}{Rendering Quality} */ @@ -1609,9 +1614,8 @@ void QPainter::restore() tmp->clipPath = QPainterPath(); d->engine->updateState(*tmp); // replay the list of clip states, - for (const QPainterClipInfo &info : qAsConst(d->state->clipInfo)) { + for (const QPainterClipInfo &info : std::as_const(d->state->clipInfo)) { tmp->matrix = info.matrix; - tmp->matrix *= d->state->redirectionMatrix; tmp->clipOperation = info.operation; if (info.clipType == QPainterClipInfo::RectClip) { tmp->dirtyFlags = QPaintEngine::DirtyClipRegion | QPaintEngine::DirtyTransform; @@ -1761,9 +1765,12 @@ bool QPainter::begin(QPaintDevice *pd) qWarning("QPainter::begin: Cannot paint on a null image"); qt_cleanup_painter_state(d); return false; - } else if (img->format() == QImage::Format_Indexed8) { - // Painting on indexed8 images is not supported. - qWarning("QPainter::begin: Cannot paint on an image with the QImage::Format_Indexed8 format"); + } else if (img->format() == QImage::Format_Indexed8 || + img->format() == QImage::Format_CMYK8888) { + // Painting on these formats is not supported. + qWarning() << "QPainter::begin: Cannot paint on an image with the" + << img->format() + << "format"; qt_cleanup_painter_state(d); return false; } @@ -1818,7 +1825,7 @@ bool QPainter::begin(QPaintDevice *pd) Q_ASSERT(d->engine->isActive()); - if (!d->state->redirectionMatrix.isIdentity() || d->effectiveDevicePixelRatio() > 1) + if (!d->state->redirectionMatrix.isIdentity() || !qFuzzyCompare(d->effectiveDevicePixelRatio(), qreal(1.0))) d->updateMatrix(); Q_ASSERT(d->engine->isActive()); @@ -2471,7 +2478,7 @@ QRegion QPainter::clipRegion() const const_cast<QPainter *>(this)->d_ptr->updateInvMatrix(); // ### Falcon: Use QPainterPath - for (const QPainterClipInfo &info : qAsConst(d->state->clipInfo)) { + for (const QPainterClipInfo &info : std::as_const(d->state->clipInfo)) { switch (info.clipType) { case QPainterClipInfo::RegionClip: { @@ -2638,7 +2645,7 @@ QRectF QPainter::clipBoundingRect() const // fast. QRectF bounds; bool first = true; - for (const QPainterClipInfo &info : qAsConst(d->state->clipInfo)) { + for (const QPainterClipInfo &info : std::as_const(d->state->clipInfo)) { QRectF r; if (info.clipType == QPainterClipInfo::RectClip) @@ -3895,8 +3902,10 @@ void QPainter::drawRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius, #endif Q_D(QPainter); - if (!d->engine) + if (!d->engine) { + qWarning("QPainter::drawRoundedRect: Painter not active"); return; + } if (xRadius <= 0 || yRadius <= 0) { // draw normal rectangle drawRect(rect); @@ -3957,8 +3966,10 @@ void QPainter::drawEllipse(const QRectF &r) #endif Q_D(QPainter); - if (!d->engine) + if (!d->engine) { + qWarning("QPainter::drawEllipse: Painter not active"); return; + } QRectF rect(r.normalized()); @@ -3998,8 +4009,10 @@ void QPainter::drawEllipse(const QRect &r) #endif Q_D(QPainter); - if (!d->engine) + if (!d->engine) { + qWarning("QPainter::drawEllipse: Painter not active"); return; + } QRect rect(r.normalized()); @@ -4085,8 +4098,10 @@ void QPainter::drawArc(const QRectF &r, int a, int alen) #endif Q_D(QPainter); - if (!d->engine) + if (!d->engine) { + qWarning("QPainter::drawArc: Painter not active"); return; + } QRectF rect = r.normalized(); @@ -4147,8 +4162,10 @@ void QPainter::drawPie(const QRectF &r, int a, int alen) #endif Q_D(QPainter); - if (!d->engine) + if (!d->engine) { + qWarning("QPainter::drawPie: Painter not active"); return; + } if (a > (360*16)) { a = a % (360*16); @@ -4216,8 +4233,10 @@ void QPainter::drawChord(const QRectF &r, int a, int alen) #endif Q_D(QPainter); - if (!d->engine) + if (!d->engine) { + qWarning("QPainter::drawChord: Painter not active"); return; + } QRectF rect = r.normalized(); @@ -5442,9 +5461,13 @@ void QPainter::drawStaticText(const QPointF &topLeftPosition, const QStaticText QStaticTextPrivate *staticText_d = const_cast<QStaticTextPrivate *>(QStaticTextPrivate::get(&staticText)); - if (font() != staticText_d->font) { + QFontPrivate *fp = QFontPrivate::get(font()); + QFontPrivate *stfp = QFontPrivate::get(staticText_d->font); + if (font() != staticText_d->font || fp == nullptr || stfp == nullptr || fp->dpi != stfp->dpi) { staticText_d->font = font(); staticText_d->needsRelayout = true; + } else if (stfp->engineData == nullptr || stfp->engineData->fontCacheId != QFontCache::instance()->id()) { + staticText_d->needsRelayout = true; } QFontEngine *fe = staticText_d->font.d->engineForScript(QChar::Script_Common); @@ -5582,7 +5605,7 @@ void QPainter::drawText(const QPointF &p, const QString &str, int tf, int justif } engine.itemize(); QScriptLine line; - line.length = str.length(); + line.length = str.size(); engine.shapeLine(line); int nItems = engine.layoutData->items.size(); @@ -5637,7 +5660,7 @@ void QPainter::drawText(const QRect &r, int flags, const QString &str, QRect *br Q_D(QPainter); - if (!d->engine || str.length() == 0 || pen().style() == Qt::NoPen) + if (!d->engine || str.size() == 0 || pen().style() == Qt::NoPen) return; if (!d->extended) @@ -5724,7 +5747,7 @@ void QPainter::drawText(const QRectF &r, int flags, const QString &str, QRectF * Q_D(QPainter); - if (!d->engine || str.length() == 0 || pen().style() == Qt::NoPen) + if (!d->engine || str.size() == 0 || pen().style() == Qt::NoPen) return; if (!d->extended) @@ -5843,7 +5866,7 @@ void QPainter::drawText(const QRectF &r, const QString &text, const QTextOption Q_D(QPainter); - if (!d->engine || text.length() == 0 || pen().style() == Qt::NoPen) + if (!d->engine || text.size() == 0 || pen().style() == Qt::NoPen) return; if (!d->extended) @@ -6334,7 +6357,7 @@ QRectF QPainter::boundingRect(const QRectF &r, const QString &text, const QTextO { Q_D(QPainter); - if (!d->engine || text.length() == 0) + if (!d->engine || text.size() == 0) return QRectF(r.x(),r.y(), 0,0); QRectF br; @@ -6499,8 +6522,10 @@ void QPainter::drawPicture(const QPointF &p, const QPicture &picture) { Q_D(QPainter); - if (!d->engine) + if (!d->engine) { + qWarning("QPainter::drawPicture: Painter not active"); return; + } if (!d->extended) d->updateState(d->state); @@ -6611,8 +6636,10 @@ void QPainter::fillRect(const QRectF &r, const QBrush &brush) { Q_D(QPainter); - if (!d->engine) + if (!d->engine) { + qWarning("QPainter::fillRect: Painter not active"); return; + } if (d->extended && !needsEmulation(brush)) { d->extended->fillRect(r, brush); @@ -6646,8 +6673,10 @@ void QPainter::fillRect(const QRect &r, const QBrush &brush) { Q_D(QPainter); - if (!d->engine) + if (!d->engine) { + qWarning("QPainter::fillRect: Painter not active"); return; + } if (d->extended && !needsEmulation(brush)) { d->extended->fillRect(r, brush); @@ -6684,8 +6713,10 @@ void QPainter::fillRect(const QRect &r, const QColor &color) { Q_D(QPainter); - if (!d->engine) + if (!d->engine) { + qWarning("QPainter::fillRect: Painter not active"); return; + } if (d->extended) { d->extended->fillRect(r, color); @@ -7124,7 +7155,7 @@ start_lengthVariant: // compatible behaviour to the old implementation. Replace // tabs by spaces int old_offset = offset; - for (; offset < text.length(); offset++) { + for (; offset < text.size(); offset++) { QChar chr = text.at(offset); if (chr == u'\r' || (singleline && chr == u'\n')) { text[offset] = u' '; diff --git a/src/gui/painting/qpainter.h b/src/gui/painting/qpainter.h index ce3d1fabdb..7bcacb4bca 100644 --- a/src/gui/painting/qpainter.h +++ b/src/gui/painting/qpainter.h @@ -54,6 +54,7 @@ public: SmoothPixmapTransform = 0x04, VerticalSubpixelPositioning = 0x08, LosslessImageRendering = 0x40, + NonCosmeticBrushPatterns = 0x80 }; Q_ENUM(RenderHint) diff --git a/src/gui/painting/qpainterpath.cpp b/src/gui/painting/qpainterpath.cpp index 851df3e7ae..8d23d167b0 100644 --- a/src/gui/painting/qpainterpath.cpp +++ b/src/gui/painting/qpainterpath.cpp @@ -517,10 +517,8 @@ QPainterPath::QPainterPath(const QPainterPath &other) = default; */ QPainterPath::QPainterPath(const QPointF &startPoint) - : d_ptr(new QPainterPathPrivate) + : d_ptr(new QPainterPathPrivate(startPoint)) { - Element e = { startPoint.x(), startPoint.y(), MoveToElement }; - d_func()->elements << e; } void QPainterPath::detach() @@ -1135,6 +1133,9 @@ void QPainterPath::addEllipse(const QRectF &boundingRect) that the left end of the text's baseline lies at the specified \a point. + Some fonts may yield overlapping subpaths and will require the + \c Qt::WindingFill fill rule for correct rendering. + \table 100% \row \li \inlineimage qpainterpath-addtext.png @@ -1143,7 +1144,7 @@ void QPainterPath::addEllipse(const QRectF &boundingRect) \endtable \sa QPainter::drawText(), {QPainterPath#Composing a - QPainterPath}{Composing a QPainterPath} + QPainterPath}{Composing a QPainterPath}, setFillRule() */ void QPainterPath::addText(const QPointF &point, const QFont &f, const QString &text) { @@ -1488,7 +1489,7 @@ QRectF QPainterPath::controlPointRect() const bool QPainterPath::isEmpty() const { - return !d_ptr || (d_ptr->elements.size() == 1 && d_ptr->elements.first().type == MoveToElement); + return !d_ptr || (d_ptr->elements.size() == 1 && d_ptr->elements.constFirst().type == MoveToElement); } /*! @@ -2441,14 +2442,14 @@ QDataStream &operator>>(QDataStream &s, QPainterPath &p) int size; s >> size; - if (size == 0) + if (size == 0) { + p = {}; return s; + } p.ensureData(); // in case if p.d_func() == 0 - if (p.d_func()->elements.size() == 1) { - Q_ASSERT(p.d_func()->elements.at(0).type == QPainterPath::MoveToElement); - p.d_func()->elements.clear(); - } + p.detach(); + p.d_func()->elements.clear(); for (int i=0; i<size; ++i) { int type; double x, y; @@ -2471,9 +2472,7 @@ QDataStream &operator>>(QDataStream &s, QPainterPath &p) s >> fillRule; Q_ASSERT(fillRule == Qt::OddEvenFill || fillRule == Qt::WindingFill); p.d_func()->fillRule = Qt::FillRule(fillRule); - p.d_func()->dirtyBounds = true; - p.d_func()->dirtyControlBounds = true; - if (errorDetected) + if (errorDetected || p.d_func()->elements.isEmpty()) p = QPainterPath(); // Better than to return path with possibly corrupt datastructure, which would likely cause crash return s; } diff --git a/src/gui/painting/qpainterpath_p.h b/src/gui/painting/qpainterpath_p.h index 55164bc347..a07b6cca37 100644 --- a/src/gui/painting/qpainterpath_p.h +++ b/src/gui/painting/qpainterpath_p.h @@ -119,6 +119,21 @@ public: { } + QPainterPathPrivate(QPointF startPoint) + : QSharedData(), + elements{ { startPoint.x(), startPoint.y(), QPainterPath::MoveToElement } }, + cStart(0), + fillRule(Qt::OddEvenFill), + bounds(startPoint, QSizeF(0, 0)), + controlBounds(startPoint, QSizeF(0, 0)), + require_moveTo(false), + dirtyBounds(false), + dirtyControlBounds(false), + convex(false), + pathConverter(nullptr) + { + } + QPainterPathPrivate(const QPainterPathPrivate &other) noexcept : QSharedData(other), elements(other.elements), diff --git a/src/gui/painting/qpathclipper.cpp b/src/gui/painting/qpathclipper.cpp index e0b4e5152c..10a0639b53 100644 --- a/src/gui/painting/qpathclipper.cpp +++ b/src/gui/painting/qpathclipper.cpp @@ -63,6 +63,7 @@ struct QIntersection QPointF pos; }; +Q_DECLARE_TYPEINFO(QIntersection, Q_PRIMITIVE_TYPE); class QIntersectionFinder { @@ -649,7 +650,8 @@ int QKdPointTree::build(int begin, int end, int depth) } } - qSwap(m_nodes.at(last), m_nodes.at(begin)); + if (last != begin) + qSwap(m_nodes.at(last), m_nodes.at(begin)); if (last > begin) m_nodes.at(last).left = &m_nodes.at(build(begin, last, depth + 1)); diff --git a/src/gui/painting/qpathclipper_p.h b/src/gui/painting/qpathclipper_p.h index b6cb65630f..f13b96e0ef 100644 --- a/src/gui/painting/qpathclipper_p.h +++ b/src/gui/painting/qpathclipper_p.h @@ -79,6 +79,7 @@ public: qreal x; qreal y; }; +Q_DECLARE_TYPEINFO(QPathVertex, Q_PRIMITIVE_TYPE); class QPathEdge { @@ -122,6 +123,7 @@ public: private: int m_next[2][2] = { { -1, -1 }, { -1, -1 } }; }; +Q_DECLARE_TYPEINFO(QPathEdge, Q_PRIMITIVE_TYPE); class QPathSegments { @@ -135,6 +137,7 @@ public: return t < o.t; } }; + friend class QTypeInfo<Intersection>; struct Segment { Segment(int pathId, int vertexA, int vertexB) @@ -156,6 +159,7 @@ public: QRectF bounds; }; + friend class QTypeInfo<Segment>; QPathSegments(int reserve); @@ -187,6 +191,8 @@ private: int m_pathId; }; +Q_DECLARE_TYPEINFO(QPathSegments::Intersection, Q_PRIMITIVE_TYPE); +Q_DECLARE_TYPEINFO(QPathSegments::Segment, Q_PRIMITIVE_TYPE); class Q_AUTOTEST_EXPORT QWingedEdge { diff --git a/src/gui/painting/qpathsimplifier.cpp b/src/gui/painting/qpathsimplifier.cpp index af702435c5..969308f0bb 100644 --- a/src/gui/painting/qpathsimplifier.cpp +++ b/src/gui/painting/qpathsimplifier.cpp @@ -8,7 +8,9 @@ #include <QtCore/qpoint.h> #include <QtCore/qalgorithms.h> -#include <private/qopengl_p.h> +#if QT_CONFIG(opengl) +# include <private/qopengl_p.h> +#endif #include <private/qrbtree_p.h> QT_BEGIN_NAMESPACE @@ -303,6 +305,7 @@ private: Type type; Element *element; }; + friend class QTypeInfo<Event>; typedef QRBTree<Element *>::Node RBNode; typedef BoundingVolumeHierarchy::Node BVHNode; @@ -341,6 +344,10 @@ private: uint m_hints; }; +} // unnamed namespace + +Q_DECLARE_TYPEINFO(PathSimplifier::Event, Q_PRIMITIVE_TYPE); + inline PathSimplifier::BoundingVolumeHierarchy::BoundingVolumeHierarchy() : root(nullptr) , nodeBlock(nullptr) @@ -1614,9 +1621,6 @@ void PathSimplifier::sortEvents(Event *events, int count) } } -} // end anonymous namespace - - void qSimplifyPath(const QVectorPath &path, QDataBuffer<QPoint> &vertices, QDataBuffer<quint32> &indices, const QTransform &matrix) { @@ -1631,3 +1635,5 @@ void qSimplifyPath(const QPainterPath &path, QDataBuffer<QPoint> &vertices, QT_END_NAMESPACE + +#undef Q_FIXED_POINT_SCALE diff --git a/src/gui/painting/qpdf.cpp b/src/gui/painting/qpdf.cpp index ddfec47c6f..38f2a9b803 100644 --- a/src/gui/painting/qpdf.cpp +++ b/src/gui/painting/qpdf.cpp @@ -7,6 +7,7 @@ #include "qplatformdefs.h" +#include <private/qcmyk_p.h> #include <private/qfont_p.h> #include <private/qmath_p.h> #include <private/qpainter_p.h> @@ -44,7 +45,7 @@ QT_BEGIN_NAMESPACE using namespace Qt::StringLiterals; -inline QPaintEngine::PaintEngineFeatures qt_pdf_decide_features() +constexpr QPaintEngine::PaintEngineFeatures qt_pdf_decide_features() { QPaintEngine::PaintEngineFeatures f = QPaintEngine::AllFeatures; f &= ~(QPaintEngine::PorterDuff @@ -99,7 +100,7 @@ static void removeTransparencyFromBrush(QBrush &brush) const char *qt_real_to_string(qreal val, char *buf) { const char *ret = buf; - if (qIsNaN(val)) { + if (!qIsFinite(val) || std::abs(val) > std::numeric_limits<quint32>::max()) { *(buf++) = '0'; *(buf++) = ' '; *buf = 0; @@ -110,8 +111,8 @@ const char *qt_real_to_string(qreal val, char *buf) { *(buf++) = '-'; val = -val; } - unsigned int ival = (unsigned int) val; - qreal frac = val - (qreal)ival; + qreal frac = std::modf(val, &val); + quint32 ival(val); int ifrac = (int)(frac * 1000000000); if (ifrac == 1000000000) { @@ -270,13 +271,6 @@ namespace QPdf { dev->open(QIODevice::ReadWrite | QIODevice::Truncate); } - void ByteStream::constructor_helper(QByteArray *ba) - { - delete dev; - dev = new QBuffer(ba); - dev->open(QIODevice::ReadWrite); - } - void ByteStream::prepareBuffer() { Q_ASSERT(!dev->isSequential()); @@ -285,16 +279,17 @@ namespace QPdf { && size > maxMemorySize()) { // Switch to file backing. QTemporaryFile *newFile = new QTemporaryFile; - newFile->open(); - dev->reset(); - while (!dev->atEnd()) { - QByteArray buf = dev->read(chunkSize()); - newFile->write(buf); + if (newFile->open()) { + dev->reset(); + while (!dev->atEnd()) { + QByteArray buf = dev->read(chunkSize()); + newFile->write(buf); + } + delete dev; + dev = newFile; + ba.clear(); + fileBackingActive = true; } - delete dev; - dev = newFile; - ba.clear(); - fileBackingActive = true; } if (dev->pos() != size) { dev->seek(size); @@ -1081,6 +1076,9 @@ void QPdfEngine::updateState(const QPaintEngineState &state) QPaintEngine::DirtyFlags flags = state.state(); + if (flags & DirtyHints) + flags |= DirtyBrush; + if (flags & DirtyTransform) d->stroker.matrix = state.transform(); @@ -1213,20 +1211,18 @@ void QPdfEngine::updateClipPath(const QPainterPath &p, Qt::ClipOperation op) QPainterPath path = d->stroker.matrix.map(p); //qDebug() << "updateClipPath: " << d->stroker.matrix << p.boundingRect() << path.boundingRect() << op; - if (op == Qt::NoClip) { + switch (op) { + case Qt::NoClip: d->clipEnabled = false; d->clips.clear(); - } else if (op == Qt::ReplaceClip) { + break; + case Qt::ReplaceClip: d->clips.clear(); d->clips.append(path); - } else if (op == Qt::IntersectClip) { - d->clips.append(path); - } else { // UniteClip - // ask the painter for the current clipping path. that's the easiest solution - path = painter()->clipPath(); - path = d->stroker.matrix.map(path); - d->clips.clear(); + break; + case Qt::IntersectClip: d->clips.append(path); + break; } } @@ -1238,17 +1234,8 @@ void QPdfEngine::setPen() QBrush b = d->pen.brush(); Q_ASSERT(b.style() == Qt::SolidPattern && b.isOpaque()); - QColor rgba = b.color(); - if (d->grayscale) { - qreal gray = qGray(rgba.rgba())/255.; - *d->currentPage << gray << gray << gray; - } else { - *d->currentPage << rgba.redF() - << rgba.greenF() - << rgba.blueF(); - } + d->writeColor(QPdfEnginePrivate::ColorDomain::Stroking, b.color()); *d->currentPage << "SCN\n"; - *d->currentPage << d->pen.widthF() << "w "; int pdfCapStyle = 0; @@ -1302,18 +1289,9 @@ void QPdfEngine::setBrush() if (!patternObject && !specifyColor) return; - *d->currentPage << (patternObject ? "/PCSp cs " : "/CSp cs "); - if (specifyColor) { - QColor rgba = d->brush.color(); - if (d->grayscale) { - qreal gray = qGray(rgba.rgba())/255.; - *d->currentPage << gray << gray << gray; - } else { - *d->currentPage << rgba.redF() - << rgba.greenF() - << rgba.blueF(); - } - } + const auto domain = patternObject ? QPdfEnginePrivate::ColorDomain::NonStrokingPattern + : QPdfEnginePrivate::ColorDomain::NonStroking; + d->writeColor(domain, specifyColor ? d->brush.color() : QColor()); if (patternObject) *d->currentPage << "/Pat" << patternObject; *d->currentPage << "scn\n"; @@ -1453,9 +1431,9 @@ int QPdfEngine::metric(QPaintDevice::PaintDeviceMetric metricType) const QPdfEnginePrivate::QPdfEnginePrivate() : clipEnabled(false), allClipped(false), hasPen(true), hasBrush(false), simplePen(false), needsTransform(false), pdfVersion(QPdfEngine::Version_1_4), + colorModel(QPdfEngine::ColorModel::Auto), outDevice(nullptr), ownsDevice(false), embedFonts(true), - grayscale(false), m_pageLayout(QPageSize(QPageSize::A4), QPageLayout::Portrait, QMarginsF(10, 10, 10, 10)) { initResources(); @@ -1504,12 +1482,15 @@ bool QPdfEngine::begin(QPaintDevice *pdev) d->xrefPositions.clear(); d->pageRoot = 0; - d->embeddedfilesRoot = 0; d->namesRoot = 0; + d->destsRoot = 0; + d->attachmentsRoot = 0; d->catalog = 0; d->info = 0; d->graphicsState = 0; - d->patternColorSpace = 0; + d->patternColorSpaceRGB = 0; + d->patternColorSpaceGrayscale = 0; + d->patternColorSpaceCMYK = 0; d->simplePen = false; d->needsTransform = false; @@ -1542,6 +1523,7 @@ bool QPdfEngine::end() d->outDevice = nullptr; } + d->destCache.clear(); d->fileCache.clear(); setActive(false); @@ -1590,10 +1572,7 @@ void QPdfEnginePrivate::writeHeader() catalog = addXrefEntry(-1); pageRoot = requestObject(); - if (!fileCache.isEmpty()) { - namesRoot = requestObject(); - embeddedfilesRoot = requestObject(); - } + namesRoot = requestObject(); // catalog { @@ -1601,11 +1580,8 @@ void QPdfEnginePrivate::writeHeader() QPdf::ByteStream s(&catalog); s << "<<\n" << "/Type /Catalog\n" - << "/Pages " << pageRoot << "0 R\n"; - - // Embedded files, if any - if (!fileCache.isEmpty()) - s << "/Names " << embeddedfilesRoot << "0 R\n"; + << "/Pages " << pageRoot << "0 R\n" + << "/Names " << namesRoot << "0 R\n"; if (pdfVersion == QPdfEngine::Version_A1b || !xmpDocumentMetadata.isEmpty()) s << "/Metadata " << metaDataObj << "0 R\n"; @@ -1619,12 +1595,6 @@ void QPdfEnginePrivate::writeHeader() write(catalog); } - if (!fileCache.isEmpty()) { - addXrefEntry(embeddedfilesRoot); - xprintf("<</EmbeddedFiles %d 0 R>>\n" - "endobj\n", namesRoot); - } - // graphics state graphicsState = addXrefEntry(-1); xprintf("<<\n" @@ -1638,10 +1608,108 @@ void QPdfEnginePrivate::writeHeader() ">>\n" "endobj\n"); - // color space for pattern - patternColorSpace = addXrefEntry(-1); + // color spaces for pattern + patternColorSpaceRGB = addXrefEntry(-1); xprintf("[/Pattern /DeviceRGB]\n" "endobj\n"); + patternColorSpaceGrayscale = addXrefEntry(-1); + xprintf("[/Pattern /DeviceGray]\n" + "endobj\n"); + patternColorSpaceCMYK = addXrefEntry(-1); + xprintf("[/Pattern /DeviceCMYK]\n" + "endobj\n"); +} + +QPdfEngine::ColorModel QPdfEnginePrivate::colorModelForColor(const QColor &color) const +{ + switch (colorModel) { + case QPdfEngine::ColorModel::RGB: + case QPdfEngine::ColorModel::Grayscale: + case QPdfEngine::ColorModel::CMYK: + return colorModel; + case QPdfEngine::ColorModel::Auto: + switch (color.spec()) { + case QColor::Invalid: + case QColor::Rgb: + case QColor::Hsv: + case QColor::Hsl: + case QColor::ExtendedRgb: + return QPdfEngine::ColorModel::RGB; + case QColor::Cmyk: + return QPdfEngine::ColorModel::CMYK; + } + + break; + } + + Q_UNREACHABLE_RETURN(QPdfEngine::ColorModel::RGB); +} + +void QPdfEnginePrivate::writeColor(ColorDomain domain, const QColor &color) +{ + // Switch to the right colorspace. + // For simplicity: do it even if it redundant (= already in that colorspace) + const QPdfEngine::ColorModel actualColorModel = colorModelForColor(color); + + switch (actualColorModel) { + case QPdfEngine::ColorModel::RGB: + switch (domain) { + case ColorDomain::Stroking: + *currentPage << "/CSp CS\n"; break; + case ColorDomain::NonStroking: + *currentPage << "/CSp cs\n"; break; + case ColorDomain::NonStrokingPattern: + *currentPage << "/PCSp cs\n"; break; + } + break; + case QPdfEngine::ColorModel::Grayscale: + switch (domain) { + case ColorDomain::Stroking: + *currentPage << "/CSpg CS\n"; break; + case ColorDomain::NonStroking: + *currentPage << "/CSpg cs\n"; break; + case ColorDomain::NonStrokingPattern: + *currentPage << "/PCSpg cs\n"; break; + } + break; + case QPdfEngine::ColorModel::CMYK: + switch (domain) { + case ColorDomain::Stroking: + *currentPage << "/CSpcmyk CS\n"; break; + case ColorDomain::NonStroking: + *currentPage << "/CSpcmyk cs\n"; break; + case ColorDomain::NonStrokingPattern: + *currentPage << "/PCSpcmyk cs\n"; break; + } + break; + case QPdfEngine::ColorModel::Auto: + Q_UNREACHABLE_RETURN(); + } + + // If we also have a color specified, write it out. + if (!color.isValid()) + return; + + switch (actualColorModel) { + case QPdfEngine::ColorModel::RGB: + *currentPage << color.redF() + << color.greenF() + << color.blueF(); + break; + case QPdfEngine::ColorModel::Grayscale: { + const qreal gray = qGray(color.rgba()) / 255.; + *currentPage << gray; + break; + } + case QPdfEngine::ColorModel::CMYK: + *currentPage << color.cyanF() + << color.magentaF() + << color.yellowF() + << color.blackF(); + break; + case QPdfEngine::ColorModel::Auto: + Q_UNREACHABLE_RETURN(); + } } void QPdfEnginePrivate::writeInfo() @@ -1706,7 +1774,8 @@ int QPdfEnginePrivate::writeXmpDcumentMetaData() const QString metaDataDate = timeStr + tzStr; QFile metaDataFile(":/qpdf/qpdfa_metadata.xml"_L1); - metaDataFile.open(QIODevice::ReadOnly); + bool ok = metaDataFile.open(QIODevice::ReadOnly); + Q_ASSERT(ok); metaDataContent = QString::fromUtf8(metaDataFile.readAll()).arg(producer.toHtmlEscaped(), title.toHtmlEscaped(), creator.toHtmlEscaped(), @@ -1732,7 +1801,8 @@ int QPdfEnginePrivate::writeOutputIntent() const int colorProfile = addXrefEntry(-1); { QFile colorProfileFile(":/qpdf/sRGB2014.icc"_L1); - colorProfileFile.open(QIODevice::ReadOnly); + bool ok = colorProfileFile.open(QIODevice::ReadOnly); + Q_ASSERT(ok); const QByteArray colorProfileData = colorProfileFile.readAll(); QByteArray data; @@ -1792,6 +1862,39 @@ void QPdfEnginePrivate::writePageRoot() "endobj\n"); } +void QPdfEnginePrivate::writeDestsRoot() +{ + if (destCache.isEmpty()) + return; + + QHash<QString, int> destObjects; + QByteArray xs, ys; + for (const DestInfo &destInfo : std::as_const(destCache)) { + int destObj = addXrefEntry(-1); + xs.setNum(static_cast<double>(destInfo.coords.x()), 'f'); + ys.setNum(static_cast<double>(destInfo.coords.y()), 'f'); + xprintf("[%d 0 R /XYZ %s %s 0]\n", destInfo.pageObj, xs.constData(), ys.constData()); + xprintf("endobj\n"); + destObjects.insert(destInfo.anchor, destObj); + } + + // names + destsRoot = addXrefEntry(-1); + QStringList anchors = destObjects.keys(); + anchors.sort(); + xprintf("<<\n/Limits ["); + printString(anchors.constFirst()); + xprintf(" "); + printString(anchors.constLast()); + xprintf("]\n/Names [\n"); + for (const QString &anchor : std::as_const(anchors)) { + printString(anchor); + xprintf(" %d 0 R\n", destObjects[anchor]); + } + xprintf("]\n>>\n" + "endobj\n"); +} + void QPdfEnginePrivate::writeAttachmentRoot() { if (fileCache.isEmpty()) @@ -1831,7 +1934,7 @@ void QPdfEnginePrivate::writeAttachmentRoot() } // names - addXrefEntry(namesRoot); + attachmentsRoot = addXrefEntry(-1); xprintf("<</Names["); for (int i = 0; i < size; ++i) { auto attachment = fileCache.at(i); @@ -1842,6 +1945,21 @@ void QPdfEnginePrivate::writeAttachmentRoot() "endobj\n"); } +void QPdfEnginePrivate::writeNamesRoot() +{ + addXrefEntry(namesRoot); + xprintf("<<\n"); + + if (attachmentsRoot) + xprintf("/EmbeddedFiles %d 0 R\n", attachmentsRoot); + + if (destsRoot) + xprintf("/Dests %d 0 R\n", destsRoot); + + xprintf(">>\n"); + xprintf("endobj\n"); +} + void QPdfEnginePrivate::embedFont(QFontSubset *font) { //qDebug() << "embedFont" << font->object_id; @@ -1935,7 +2053,7 @@ void QPdfEnginePrivate::embedFont(QFontSubset *font) addXrefEntry(toUnicode); QByteArray touc = font->createToUnicodeMap(); xprintf("<< /Length %d >>\n" - "stream\n", touc.length()); + "stream\n", touc.size()); write(touc); write("\nendstream\n" "endobj\n"); @@ -1958,7 +2076,7 @@ void QPdfEnginePrivate::embedFont(QFontSubset *font) QByteArray cidSetStream(font->nGlyphs() / 8 + 1, 0); int byteCounter = 0; int bitCounter = 0; - for (int i = 0; i < font->nGlyphs(); ++i) { + for (qsizetype i = 0; i < font->nGlyphs(); ++i) { cidSetStream.data()[byteCounter] |= (1 << (7 - bitCounter)); bitCounter++; @@ -2039,12 +2157,18 @@ void QPdfEnginePrivate::writePage() xprintf("<<\n" "/ColorSpace <<\n" "/PCSp %d 0 R\n" + "/PCSpg %d 0 R\n" + "/PCSpcmyk %d 0 R\n" "/CSp /DeviceRGB\n" "/CSpg /DeviceGray\n" + "/CSpcmyk /DeviceCMYK\n" ">>\n" "/ExtGState <<\n" "/GSa %d 0 R\n", - patternColorSpace, graphicsState); + patternColorSpaceRGB, + patternColorSpaceGrayscale, + patternColorSpaceCMYK, + graphicsState); for (int i = 0; i < currentPage->graphicStates.size(); ++i) xprintf("/GState%d %d 0 R\n", currentPage->graphicStates.at(i), currentPage->graphicStates.at(i)); @@ -2098,7 +2222,9 @@ void QPdfEnginePrivate::writeTail() writePage(); writeFonts(); writePageRoot(); + writeDestsRoot(); writeAttachmentRoot(); + writeNamesRoot(); addXrefEntry(xrefPositions.size(),false); xprintf("xref\n" @@ -2277,16 +2403,15 @@ int QPdfEnginePrivate::writeCompressed(const char *src, int len) { #ifndef QT_NO_COMPRESS if (do_compress) { - uLongf destLen = len + len/100 + 13; // zlib requirement - Bytef* dest = new Bytef[destLen]; - if (Z_OK == ::compress(dest, &destLen, (const Bytef*) src, (uLongf)len)) { - stream->writeRawData((const char*)dest, destLen); + const QByteArray data = qCompress(reinterpret_cast<const uchar *>(src), len); + constexpr qsizetype HeaderSize = 4; + if (!data.isNull()) { + stream->writeRawData(data.data() + HeaderSize, data.size() - HeaderSize); + len = data.size() - HeaderSize; } else { qWarning("QPdfStream::writeCompressed: Error in compress()"); - destLen = 0; + len = 0; } - delete [] dest; - len = destLen; } else #endif { @@ -2296,7 +2421,7 @@ int QPdfEnginePrivate::writeCompressed(const char *src, int len) return len; } -int QPdfEnginePrivate::writeImage(const QByteArray &data, int width, int height, int depth, +int QPdfEnginePrivate::writeImage(const QByteArray &data, int width, int height, WriteImageOption option, int maskObject, int softMaskObject, bool dct, bool isMono) { int image = addXrefEntry(-1); @@ -2306,7 +2431,8 @@ int QPdfEnginePrivate::writeImage(const QByteArray &data, int width, int height, "/Width %d\n" "/Height %d\n", width, height); - if (depth == 1) { + switch (option) { + case WriteImageOption::Monochrome: if (!isMono) { xprintf("/ImageMask true\n" "/Decode [1 0]\n"); @@ -2314,10 +2440,21 @@ int QPdfEnginePrivate::writeImage(const QByteArray &data, int width, int height, xprintf("/BitsPerComponent 1\n" "/ColorSpace /DeviceGray\n"); } - } else { + break; + case WriteImageOption::Grayscale: xprintf("/BitsPerComponent 8\n" - "/ColorSpace %s\n", (depth == 32) ? "/DeviceRGB" : "/DeviceGray"); + "/ColorSpace /DeviceGray\n"); + break; + case WriteImageOption::RGB: + xprintf("/BitsPerComponent 8\n" + "/ColorSpace /DeviceRGB\n"); + break; + case WriteImageOption::CMYK: + xprintf("/BitsPerComponent 8\n" + "/ColorSpace /DeviceCMYK\n"); + break; } + if (maskObject > 0) xprintf("/Mask %d 0 R\n", maskObject); if (softMaskObject > 0) @@ -2332,7 +2469,7 @@ int QPdfEnginePrivate::writeImage(const QByteArray &data, int width, int height, //qDebug("DCT"); xprintf("/Filter /DCTDecode\n>>\nstream\n"); write(data); - len = data.length(); + len = data.size(); } else { if (do_compress) xprintf("/Filter /FlateDecode\n>>\nstream\n"); @@ -2356,7 +2493,23 @@ struct QGradientBound { }; Q_DECLARE_TYPEINFO(QGradientBound, Q_PRIMITIVE_TYPE); -int QPdfEnginePrivate::createShadingFunction(const QGradient *gradient, int from, int to, bool reflect, bool alpha) +void QPdfEnginePrivate::ShadingFunctionResult::writeColorSpace(QPdf::ByteStream *stream) const +{ + *stream << "/ColorSpace "; + switch (colorModel) { + case QPdfEngine::ColorModel::RGB: + *stream << "/DeviceRGB\n"; break; + case QPdfEngine::ColorModel::Grayscale: + *stream << "/DeviceGray\n"; break; + case QPdfEngine::ColorModel::CMYK: + *stream << "/DeviceCMYK\n"; break; + case QPdfEngine::ColorModel::Auto: + Q_UNREACHABLE(); break; + } +} + +QPdfEnginePrivate::ShadingFunctionResult +QPdfEnginePrivate::createShadingFunction(const QGradient *gradient, int from, int to, bool reflect, bool alpha) { QGradientStops stops = gradient->stops(); if (stops.isEmpty()) { @@ -2368,6 +2521,35 @@ int QPdfEnginePrivate::createShadingFunction(const QGradient *gradient, int from if (stops.at(stops.size() - 1).first < 1) stops.append(QGradientStop(1, stops.at(stops.size() - 1).second)); + // Color to use which colorspace to use + const QColor referenceColor = stops.constFirst().second; + + switch (colorModel) { + case QPdfEngine::ColorModel::RGB: + case QPdfEngine::ColorModel::Grayscale: + case QPdfEngine::ColorModel::CMYK: + break; + case QPdfEngine::ColorModel::Auto: { + // Make sure that all the stops have the same color spec + // (we don't support anything else) + const QColor::Spec referenceSpec = referenceColor.spec(); + bool warned = false; + for (QGradientStop &stop : stops) { + if (stop.second.spec() != referenceSpec) { + if (!warned) { + qWarning("QPdfEngine: unable to create a gradient between colors of different spec"); + warned = true; + } + stop.second = stop.second.convertTo(referenceSpec); + } + } + break; + } + } + + ShadingFunctionResult result; + result.colorModel = colorModelForColor(referenceColor); + QList<int> functions; const int numStops = stops.size(); functions.reserve(numStops - 1); @@ -2383,8 +2565,31 @@ int QPdfEnginePrivate::createShadingFunction(const QGradient *gradient, int from s << "/C0 [" << stops.at(i).second.alphaF() << "]\n" "/C1 [" << stops.at(i + 1).second.alphaF() << "]\n"; } else { - s << "/C0 [" << stops.at(i).second.redF() << stops.at(i).second.greenF() << stops.at(i).second.blueF() << "]\n" - "/C1 [" << stops.at(i + 1).second.redF() << stops.at(i + 1).second.greenF() << stops.at(i + 1).second.blueF() << "]\n"; + switch (result.colorModel) { + case QPdfEngine::ColorModel::RGB: + s << "/C0 [" << stops.at(i).second.redF() << stops.at(i).second.greenF() << stops.at(i).second.blueF() << "]\n" + "/C1 [" << stops.at(i + 1).second.redF() << stops.at(i + 1).second.greenF() << stops.at(i + 1).second.blueF() << "]\n"; + break; + case QPdfEngine::ColorModel::Grayscale: + s << "/C0 [" << (qGray(stops.at(i).second.rgba()) / 255.) << "]\n" + "/C1 [" << (qGray(stops.at(i + 1).second.rgba()) / 255.) << "]\n"; + break; + case QPdfEngine::ColorModel::CMYK: + s << "/C0 [" << stops.at(i).second.cyanF() + << stops.at(i).second.magentaF() + << stops.at(i).second.yellowF() + << stops.at(i).second.blackF() << "]\n" + "/C1 [" << stops.at(i + 1).second.cyanF() + << stops.at(i + 1).second.magentaF() + << stops.at(i + 1).second.yellowF() + << stops.at(i + 1).second.blackF() << "]\n"; + break; + + case QPdfEngine::ColorModel::Auto: + Q_UNREACHABLE(); + break; + } + } s << ">>\n" "endobj\n"; @@ -2452,7 +2657,8 @@ int QPdfEnginePrivate::createShadingFunction(const QGradient *gradient, int from } else { function = functions.at(0); } - return function; + result.function = function; + return result; } int QPdfEnginePrivate::generateLinearGradientShader(const QLinearGradient *gradient, const QTransform &matrix, bool alpha) @@ -2498,17 +2704,22 @@ int QPdfEnginePrivate::generateLinearGradientShader(const QLinearGradient *gradi } } - int function = createShadingFunction(gradient, from, to, reflect, alpha); + const auto shadingFunctionResult = createShadingFunction(gradient, from, to, reflect, alpha); QByteArray shader; QPdf::ByteStream s(&shader); s << "<<\n" - "/ShadingType 2\n" - "/ColorSpace " << (alpha ? "/DeviceGray\n" : "/DeviceRGB\n") << - "/AntiAlias true\n" + "/ShadingType 2\n"; + + if (alpha) + s << "/ColorSpace /DeviceGray\n"; + else + shadingFunctionResult.writeColorSpace(&s); + + s << "/AntiAlias true\n" "/Coords [" << start.x() << start.y() << stop.x() << stop.y() << "]\n" "/Extend [true true]\n" - "/Function " << function << "0 R\n" + "/Function " << shadingFunctionResult.function << "0 R\n" ">>\n" "endobj\n"; int shaderObject = addXrefEntry(-1); @@ -2566,18 +2777,23 @@ int QPdfEnginePrivate::generateRadialGradientShader(const QRadialGradient *gradi } } - int function = createShadingFunction(gradient, from, to, reflect, alpha); + const auto shadingFunctionResult = createShadingFunction(gradient, from, to, reflect, alpha); QByteArray shader; QPdf::ByteStream s(&shader); s << "<<\n" - "/ShadingType 3\n" - "/ColorSpace " << (alpha ? "/DeviceGray\n" : "/DeviceRGB\n") << - "/AntiAlias true\n" + "/ShadingType 3\n"; + + if (alpha) + s << "/ColorSpace /DeviceGray\n"; + else + shadingFunctionResult.writeColorSpace(&s); + + s << "/AntiAlias true\n" "/Domain [0 1]\n" "/Coords [" << p0.x() << p0.y() << r0 << p1.x() << p1.y() << r1 << "]\n" "/Extend [true true]\n" - "/Function " << function << "0 R\n" + "/Function " << shadingFunctionResult.function << "0 R\n" ">>\n" "endobj\n"; int shaderObject = addXrefEntry(-1); @@ -2663,7 +2879,7 @@ int QPdfEnginePrivate::gradientBrush(const QBrush &b, const QTransform &matrix, "/Shading << /Shader" << alphaShaderObject << alphaShaderObject << "0 R >>\n" ">>\n"; - f << "/Length " << content.length() << "\n" + f << "/Length " << content.size() << "\n" ">>\n" "stream\n" << content @@ -2714,18 +2930,22 @@ int QPdfEnginePrivate::addBrushPattern(const QTransform &m, bool *specifyColor, *specifyColor = true; *gStateObject = 0; - QTransform matrix = m; + const Qt::BrushStyle style = brush.style(); + const bool isCosmetic = style >= Qt::Dense1Pattern && style <= Qt::DiagCrossPattern + && !q->painter()->testRenderHint(QPainter::NonCosmeticBrushPatterns); + QTransform matrix; + if (!isCosmetic) + matrix = m; matrix.translate(brushOrigin.x(), brushOrigin.y()); matrix = matrix * pageMatrix(); - //qDebug() << brushOrigin << matrix; - Qt::BrushStyle style = brush.style(); if (style == Qt::LinearGradientPattern || style == Qt::RadialGradientPattern) {// && style <= Qt::ConicalGradientPattern) { *specifyColor = false; return gradientBrush(brush, matrix, gStateObject); } - matrix = brush.transform() * matrix; + if (!isCosmetic) + matrix = brush.transform() * matrix; if ((!brush.isOpaque() && brush.style() < Qt::LinearGradientPattern) || opacity != 1.0) *gStateObject = addConstantAlphaObject(qRound(brush.color().alpha() * opacity), @@ -2777,7 +2997,7 @@ int QPdfEnginePrivate::addBrushPattern(const QTransform &m, bool *specifyColor, s << "/XObject << /Im" << imageObject << ' ' << imageObject << "0 R >> "; } s << ">>\n" - "/Length " << pattern.length() << "\n" + "/Length " << pattern.size() << "\n" ">>\n" "stream\n" << pattern @@ -2812,6 +3032,7 @@ int QPdfEnginePrivate::addImage(const QImage &img, bool *bitmap, bool lossless, QImage image = img; QImage::Format format = image.format(); + const bool grayscale = (colorModel == QPdfEngine::ColorModel::Grayscale); if (pdfVersion == QPdfEngine::Version_A1b) { if (image.hasAlphaChannel()) { @@ -2835,7 +3056,7 @@ int QPdfEnginePrivate::addImage(const QImage &img, bool *bitmap, bool lossless, format = QImage::Format_Mono; } else { *bitmap = false; - if (format != QImage::Format_RGB32 && format != QImage::Format_ARGB32) { + if (format != QImage::Format_RGB32 && format != QImage::Format_ARGB32 && format != QImage::Format_CMYK8888) { image = image.convertToFormat(QImage::Format_ARGB32); format = QImage::Format_ARGB32; } @@ -2843,7 +3064,6 @@ int QPdfEnginePrivate::addImage(const QImage &img, bool *bitmap, bool lossless, int w = image.width(); int h = image.height(); - int d = image.depth(); if (format == QImage::Format_Mono) { int bytesPerLine = (w + 7) >> 3; @@ -2854,7 +3074,7 @@ int QPdfEnginePrivate::addImage(const QImage &img, bool *bitmap, bool lossless, memcpy(rawdata, image.constScanLine(y), bytesPerLine); rawdata += bytesPerLine; } - object = writeImage(data, w, h, d, 0, 0, false, is_monochrome(img.colorTable())); + object = writeImage(data, w, h, WriteImageOption::Monochrome, 0, 0, false, is_monochrome(img.colorTable())); } else { QByteArray softMaskData; bool dct = false; @@ -2866,10 +3086,14 @@ int QPdfEnginePrivate::addImage(const QImage &img, bool *bitmap, bool lossless, QBuffer buffer(&imageData); QImageWriter writer(&buffer, "jpeg"); writer.setQuality(94); + if (format == QImage::Format_CMYK8888) { + // PDFs require CMYK colors not to be inverted in the JPEG encoding + writer.setSubType("CMYK"); + } writer.write(image); dct = true; - if (format != QImage::Format_RGB32) { + if (format != QImage::Format_RGB32 && format != QImage::Format_CMYK8888) { softMaskData.resize(w * h); uchar *sdata = (uchar *)softMaskData.data(); for (int y = 0; y < h; ++y) { @@ -2884,41 +3108,59 @@ int QPdfEnginePrivate::addImage(const QImage &img, bool *bitmap, bool lossless, } } } else { - imageData.resize(grayscale ? w * h : 3 * w * h); - uchar *data = (uchar *)imageData.data(); - softMaskData.resize(w * h); - uchar *sdata = (uchar *)softMaskData.data(); - for (int y = 0; y < h; ++y) { - const QRgb *rgb = (const QRgb *)image.constScanLine(y); + if (format == QImage::Format_CMYK8888) { + imageData.resize(grayscale ? w * h : w * h * 4); + uchar *data = (uchar *)imageData.data(); + const qsizetype bytesPerLine = image.bytesPerLine(); if (grayscale) { - for (int x = 0; x < w; ++x) { - *(data++) = qGray(*rgb); - uchar alpha = qAlpha(*rgb); - *sdata++ = alpha; - hasMask |= (alpha < 255); - hasAlpha |= (alpha != 0 && alpha != 255); - ++rgb; + for (int y = 0; y < h; ++y) { + const uint *cmyk = (const uint *)image.constScanLine(y); + for (int x = 0; x < w; ++x) + *data++ = qGray(QCmyk32::fromCmyk32(*cmyk++).toColor().rgba()); } } else { - for (int x = 0; x < w; ++x) { - *(data++) = qRed(*rgb); - *(data++) = qGreen(*rgb); - *(data++) = qBlue(*rgb); - uchar alpha = qAlpha(*rgb); - *sdata++ = alpha; - hasMask |= (alpha < 255); - hasAlpha |= (alpha != 0 && alpha != 255); - ++rgb; + for (int y = 0; y < h; ++y) { + uchar *start = data + y * w * 4; + memcpy(start, image.constScanLine(y), bytesPerLine); + } + } + } else { + imageData.resize(grayscale ? w * h : 3 * w * h); + uchar *data = (uchar *)imageData.data(); + softMaskData.resize(w * h); + uchar *sdata = (uchar *)softMaskData.data(); + for (int y = 0; y < h; ++y) { + const QRgb *rgb = (const QRgb *)image.constScanLine(y); + if (grayscale) { + for (int x = 0; x < w; ++x) { + *(data++) = qGray(*rgb); + uchar alpha = qAlpha(*rgb); + *sdata++ = alpha; + hasMask |= (alpha < 255); + hasAlpha |= (alpha != 0 && alpha != 255); + ++rgb; + } + } else { + for (int x = 0; x < w; ++x) { + *(data++) = qRed(*rgb); + *(data++) = qGreen(*rgb); + *(data++) = qBlue(*rgb); + uchar alpha = qAlpha(*rgb); + *sdata++ = alpha; + hasMask |= (alpha < 255); + hasAlpha |= (alpha != 0 && alpha != 255); + ++rgb; + } } } } - if (format == QImage::Format_RGB32) + if (format == QImage::Format_RGB32 || format == QImage::Format_CMYK8888) hasAlpha = hasMask = false; } int maskObject = 0; int softMaskObject = 0; if (hasAlpha) { - softMaskObject = writeImage(softMaskData, w, h, 8, 0, 0); + softMaskObject = writeImage(softMaskData, w, h, WriteImageOption::Grayscale, 0, 0); } else if (hasMask) { // dither the soft mask to 1bit and add it. This also helps PDF viewers // without transparency support @@ -2934,9 +3176,18 @@ int QPdfEnginePrivate::addImage(const QImage &img, bool *bitmap, bool lossless, } mdata += bytesPerLine; } - maskObject = writeImage(mask, w, h, 1, 0, 0); + maskObject = writeImage(mask, w, h, WriteImageOption::Monochrome, 0, 0); } - object = writeImage(imageData, w, h, grayscale ? 8 : 32, + + const WriteImageOption option = [&]() { + if (grayscale) + return WriteImageOption::Grayscale; + if (format == QImage::Format_CMYK8888) + return WriteImageOption::CMYK; + return WriteImageOption::RGB; + }(); + + object = writeImage(imageData, w, h, option, maskObject, softMaskObject, dct); } imageCache.insert(serial_no, object); @@ -2947,7 +3198,9 @@ void QPdfEnginePrivate::drawTextItem(const QPointF &p, const QTextItemInt &ti) { Q_Q(QPdfEngine); - if (ti.charFormat.hasProperty(QTextFormat::AnchorHref)) { + const bool isLink = ti.charFormat.hasProperty(QTextFormat::AnchorHref); + const bool isAnchor = ti.charFormat.hasProperty(QTextFormat::AnchorName); + if (isLink || isAnchor) { qreal size = ti.fontEngine->fontDef.pixelSize; int synthesized = ti.fontEngine->synthesized(); qreal stretch = synthesized & QFontEngine::SynthesizedStretch ? ti.fontEngine->fontDef.stretch/100. : 1.; @@ -2967,32 +3220,47 @@ void QPdfEnginePrivate::drawTextItem(const QPointF &p, const QTextItemInt &ti) trans.map(0, 0, &x1, &y1); trans.map(ti.width.toReal()/size, (ti.ascent.toReal()-ti.descent.toReal())/size, &x2, &y2); - uint annot = addXrefEntry(-1); - QByteArray x1s, y1s, x2s, y2s; - x1s.setNum(static_cast<double>(x1), 'f'); - y1s.setNum(static_cast<double>(y1), 'f'); - x2s.setNum(static_cast<double>(x2), 'f'); - y2s.setNum(static_cast<double>(y2), 'f'); - QByteArray rectData = x1s + ' ' + y1s + ' ' + x2s + ' ' + y2s; - xprintf("<<\n/Type /Annot\n/Subtype /Link\n"); - - if (pdfVersion == QPdfEngine::Version_A1b) - xprintf("/F 4\n"); // enable print flag, disable all other - - xprintf("/Rect ["); - xprintf(rectData.constData()); + if (isLink) { + uint annot = addXrefEntry(-1); + QByteArray x1s, y1s, x2s, y2s; + x1s.setNum(static_cast<double>(x1), 'f'); + y1s.setNum(static_cast<double>(y1), 'f'); + x2s.setNum(static_cast<double>(x2), 'f'); + y2s.setNum(static_cast<double>(y2), 'f'); + QByteArray rectData = x1s + ' ' + y1s + ' ' + x2s + ' ' + y2s; + xprintf("<<\n/Type /Annot\n/Subtype /Link\n"); + + if (pdfVersion == QPdfEngine::Version_A1b) + xprintf("/F 4\n"); // enable print flag, disable all other + + xprintf("/Rect ["); + xprintf(rectData.constData()); #ifdef Q_DEBUG_PDF_LINKS - xprintf("]\n/Border [16 16 1]\n/A <<\n"); + xprintf("]\n/Border [16 16 1]\n"); #else - xprintf("]\n/Border [0 0 0]\n/A <<\n"); + xprintf("]\n/Border [0 0 0]\n"); #endif - xprintf("/Type /Action\n/S /URI\n/URI (%s)\n", - ti.charFormat.anchorHref().toLatin1().constData()); - xprintf(">>\n>>\n"); - xprintf("endobj\n"); + const QString link = ti.charFormat.anchorHref(); + const bool isInternal = link.startsWith(QLatin1Char('#')); + if (!isInternal) { + xprintf("/A <<\n"); + xprintf("/Type /Action\n/S /URI\n/URI (%s)\n", link.toLatin1().constData()); + xprintf(">>\n"); + } else { + xprintf("/Dest "); + printString(link.sliced(1)); + xprintf("\n"); + } + xprintf(">>\n"); + xprintf("endobj\n"); - if (!currentPage->annotations.contains(annot)) { - currentPage->annotations.append(annot); + if (!currentPage->annotations.contains(annot)) { + currentPage->annotations.append(annot); + } + } else { + const QString anchor = ti.charFormat.anchorNames().constFirst(); + const uint curPage = pages.last(); + destCache.append(DestInfo({ anchor, curPage, QPointF(x1, y2) })); } } @@ -3074,7 +3342,7 @@ void QPdfEnginePrivate::drawTextItem(const QPointF &p, const QTextItemInt &ti) x += .3*y; x /= stretch; char buf[5]; - int g = font->addGlyph(glyphs[i]); + qsizetype g = font->addGlyph(glyphs[i]); *currentPage << x - last_x << last_y - y << "Td <" << QPdf::toHex((ushort)g, buf) << "> Tj\n"; last_x = x; @@ -3094,7 +3362,7 @@ void QPdfEnginePrivate::drawTextItem(const QPointF &p, const QTextItemInt &ti) x += .3*y; x /= stretch; char buf[5]; - int g = font->addGlyph(glyphs[i]); + qsizetype g = font->addGlyph(glyphs[i]); *currentPage << x - last_x << last_y - y << "Td <" << QPdf::toHex((ushort)g, buf) << "> Tj\n"; last_x = x; diff --git a/src/gui/painting/qpdf_p.h b/src/gui/painting/qpdf_p.h index 92a848e0d1..3c34e0bd7a 100644 --- a/src/gui/painting/qpdf_p.h +++ b/src/gui/painting/qpdf_p.h @@ -60,10 +60,6 @@ namespace QPdf { static inline int maxMemorySize() { return 100000000; } static inline int chunkSize() { return 10000000; } - protected: - void constructor_helper(QIODevice *dev); - void constructor_helper(QByteArray *ba); - private: void prepareBuffer(); @@ -142,7 +138,7 @@ public: }; QPdfEngine(); - QPdfEngine(QPdfEnginePrivate &d); + explicit QPdfEngine(QPdfEnginePrivate &d); ~QPdfEngine() {} void setOutputFilename(const QString &filename); @@ -157,6 +153,18 @@ public: void addFileAttachment(const QString &fileName, const QByteArray &data, const QString &mimeType); + // keep in sync with QPdfWriter + enum class ColorModel + { + RGB, + Grayscale, + CMYK, + Auto, + }; + + ColorModel colorModel() const; + void setColorModel(ColorModel model); + // reimplementations QPaintEngine bool begin(QPaintDevice *pdev) override; bool end() override; @@ -240,6 +248,7 @@ public: bool needsTransform; qreal opacity; QPdfEngine::PdfVersion pdfVersion; + QPdfEngine::ColorModel colorModel; QHash<QFontEngine::FaceId, QFontSubset *> fonts; @@ -255,7 +264,6 @@ public: QString creator; bool embedFonts; int resolution; - bool grayscale; // Page layout: size, orientation and margins QPageLayout m_pageLayout; @@ -265,13 +273,29 @@ private: int generateGradientShader(const QGradient *gradient, const QTransform &matrix, bool alpha = false); int generateLinearGradientShader(const QLinearGradient *lg, const QTransform &matrix, bool alpha); int generateRadialGradientShader(const QRadialGradient *gradient, const QTransform &matrix, bool alpha); - int createShadingFunction(const QGradient *gradient, int from, int to, bool reflect, bool alpha); + struct ShadingFunctionResult + { + int function; + QPdfEngine::ColorModel colorModel; + void writeColorSpace(QPdf::ByteStream *stream) const; + }; + ShadingFunctionResult createShadingFunction(const QGradient *gradient, int from, int to, bool reflect, bool alpha); + enum class ColorDomain { + Stroking, + NonStroking, + NonStrokingPattern, + }; + + QPdfEngine::ColorModel colorModelForColor(const QColor &color) const; + void writeColor(ColorDomain domain, const QColor &color); void writeInfo(); int writeXmpDcumentMetaData(); int writeOutputIntent(); void writePageRoot(); + void writeDestsRoot(); void writeAttachmentRoot(); + void writeNamesRoot(); void writeFonts(); void embedFont(QFontSubset *font); qreal calcUserUnit() const; @@ -280,7 +304,15 @@ private: QDataStream* stream; int streampos; - int writeImage(const QByteArray &data, int width, int height, int depth, + enum class WriteImageOption + { + Monochrome, + Grayscale, + RGB, + CMYK, + }; + + int writeImage(const QByteArray &data, int width, int height, WriteImageOption option, int maskObject, int softMaskObject, bool dct = false, bool isMono = false); void writePage(); @@ -293,7 +325,7 @@ private: } int writeCompressed(const char *src, int len); - inline int writeCompressed(const QByteArray &data) { return writeCompressed(data.constData(), data.length()); } + inline int writeCompressed(const QByteArray &data) { return writeCompressed(data.constData(), data.size()); } int writeCompressed(QIODevice *dev); struct AttachmentInfo @@ -305,11 +337,23 @@ private: QString mimeType; }; + struct DestInfo + { + QString anchor; + uint pageObj; + QPointF coords; + }; + // various PDF objects - int pageRoot, embeddedfilesRoot, namesRoot, catalog, info, graphicsState, patternColorSpace; + int pageRoot, namesRoot, destsRoot, attachmentsRoot, catalog, info; + int graphicsState; + int patternColorSpaceRGB; + int patternColorSpaceGrayscale; + int patternColorSpaceCMYK; QList<uint> pages; QHash<qint64, uint> imageCache; QHash<QPair<uint, uint>, uint > alphaCache; + QList<DestInfo> destCache; QList<AttachmentInfo> fileCache; QByteArray xmpDocumentMetadata; }; diff --git a/src/gui/painting/qpdfwriter.cpp b/src/gui/painting/qpdfwriter.cpp index f28a460d7c..bce65927ab 100644 --- a/src/gui/painting/qpdfwriter.cpp +++ b/src/gui/painting/qpdfwriter.cpp @@ -295,6 +295,53 @@ bool QPdfWriter::newPage() return d->engine->newPage(); } +/*! + \enum QPdfWriter::ColorModel + \since 6.8 + + This enumeration describes the way in which the PDF engine interprets + stroking and filling colors, set as a QPainter's pen or brush (via + QPen and QBrush). + + \value RGB All colors are converted to RGB and saved as such in the + PDF. + + \value Grayscale All colors are converted to grayscale. For backwards + compatibility, they are emitted in the PDF output as RGB colors, with + identical quantities of red, green and blue. + + \value CMYK All colors are converted to CMYK and saved as such. + + \value Auto RGB colors are emitted as RGB; CMYK colors are emitted as + CMYK. Colors of any other color spec are converted to RGB. + This is the default since Qt 6.8. + + \sa QColor, QGradient +*/ + +/*! + \since 6.8 + + Returns the color model used by this PDF writer. + The default is QPdfWriter::ColorModel::Auto. +*/ +QPdfWriter::ColorModel QPdfWriter::colorModel() const +{ + Q_D(const QPdfWriter); + return static_cast<ColorModel>(d->engine->d_func()->colorModel); +} + +/*! + \since 6.8 + + Sets the color model used by this PDF writer to \a model. +*/ +void QPdfWriter::setColorModel(ColorModel model) +{ + Q_D(QPdfWriter); + d->engine->d_func()->colorModel = static_cast<QPdfEngine::ColorModel>(model); +} + QT_END_NAMESPACE #include "moc_qpdfwriter.cpp" diff --git a/src/gui/painting/qpdfwriter.h b/src/gui/painting/qpdfwriter.h index 5885c4ef1a..1a4b607b66 100644 --- a/src/gui/painting/qpdfwriter.h +++ b/src/gui/painting/qpdfwriter.h @@ -44,6 +44,18 @@ public: void addFileAttachment(const QString &fileName, const QByteArray &data, const QString &mimeType = QString()); + enum class ColorModel + { + RGB, + Grayscale, + CMYK, + Auto, + }; + Q_ENUM(ColorModel) + + ColorModel colorModel() const; + void setColorModel(ColorModel model); + protected: QPaintEngine *paintEngine() const override; int metric(PaintDeviceMetric id) const override; diff --git a/src/gui/painting/qpen.cpp b/src/gui/painting/qpen.cpp index 958539feda..d37beda6b6 100644 --- a/src/gui/painting/qpen.cpp +++ b/src/gui/painting/qpen.cpp @@ -10,8 +10,6 @@ QT_BEGIN_NAMESPACE -typedef QPenPrivate QPenData; - /*! \class QPen \inmodule QtGui @@ -193,7 +191,7 @@ typedef QPenPrivate QPenData; */ QPenPrivate::QPenPrivate(const QBrush &_brush, qreal _width, Qt::PenStyle penStyle, Qt::PenCapStyle _capStyle, Qt::PenJoinStyle _joinStyle) - : ref(1), dashOffset(0), miterLimit(2), + : dashOffset(0), miterLimit(2), cosmetic(false) { width = _width; @@ -209,17 +207,13 @@ static const Qt::PenJoinStyle qpen_default_join = Qt::BevelJoin; class QPenDataHolder { public: - QPenData *pen; + QPen::DataPtr pen; QPenDataHolder(const QBrush &brush, qreal width, Qt::PenStyle penStyle, Qt::PenCapStyle penCapStyle, Qt::PenJoinStyle _joinStyle) - : pen(new QPenData(brush, width, penStyle, penCapStyle, _joinStyle)) + : pen(new QPenPrivate(brush, width, penStyle, penCapStyle, _joinStyle)) { } - ~QPenDataHolder() - { - if (!pen->ref.deref()) - delete pen; - pen = nullptr; - } + ~QPenDataHolder() = default; + Q_DISABLE_COPY_MOVE(QPenDataHolder) }; Q_GLOBAL_STATIC_WITH_ARGS(QPenDataHolder, defaultPenInstance, @@ -234,7 +228,6 @@ Q_GLOBAL_STATIC_WITH_ARGS(QPenDataHolder, nullPenInstance, QPen::QPen() { d = defaultPenInstance()->pen; - d->ref.ref(); } /*! @@ -247,9 +240,8 @@ QPen::QPen(Qt::PenStyle style) { if (style == Qt::NoPen) { d = nullPenInstance()->pen; - d->ref.ref(); } else { - d = new QPenData(Qt::black, 1, style, qpen_default_cap, qpen_default_join); + d = new QPenPrivate(Qt::black, 1, style, qpen_default_cap, qpen_default_join); } } @@ -262,7 +254,7 @@ QPen::QPen(Qt::PenStyle style) QPen::QPen(const QColor &color) { - d = new QPenData(color, 1, Qt::SolidLine, qpen_default_cap, qpen_default_join); + d = new QPenPrivate(color, 1, Qt::SolidLine, qpen_default_cap, qpen_default_join); } @@ -277,7 +269,7 @@ QPen::QPen(const QColor &color) QPen::QPen(const QBrush &brush, qreal width, Qt::PenStyle s, Qt::PenCapStyle c, Qt::PenJoinStyle j) { - d = new QPenData(brush, width, s, c, j); + d = new QPenPrivate(brush, width, s, c, j); } /*! @@ -287,10 +279,8 @@ QPen::QPen(const QBrush &brush, qreal width, Qt::PenStyle s, Qt::PenCapStyle c, */ QPen::QPen(const QPen &p) noexcept + : d(p.d) { - d = p.d; - if (d) - d->ref.ref(); } @@ -309,11 +299,9 @@ QPen::QPen(const QPen &p) noexcept Destroys the pen. */ -QPen::~QPen() -{ - if (d && !d->ref.deref()) - delete d; -} +QPen::~QPen() = default; + +QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QPenPrivate) /*! \fn void QPen::detach() @@ -327,14 +315,7 @@ QPen::~QPen() void QPen::detach() { - if (d->ref.loadRelaxed() == 1) - return; - - QPenData *x = new QPenData(*static_cast<QPenData *>(d)); - if (!d->ref.deref()) - delete d; - x->ref.storeRelaxed(1); - d = x; + d.detach(); } @@ -407,9 +388,8 @@ void QPen::setStyle(Qt::PenStyle s) return; detach(); d->style = s; - QPenData *dd = static_cast<QPenData *>(d); - dd->dashPattern.clear(); - dd->dashOffset = 0; + d->dashPattern.clear(); + d->dashOffset = 0; } /*! @@ -419,36 +399,35 @@ void QPen::setStyle(Qt::PenStyle s) */ QList<qreal> QPen::dashPattern() const { - QPenData *dd = static_cast<QPenData *>(d); if (d->style == Qt::SolidLine || d->style == Qt::NoPen) { return QList<qreal>(); - } else if (dd->dashPattern.isEmpty()) { + } else if (d->dashPattern.isEmpty()) { const qreal space = 2; const qreal dot = 1; const qreal dash = 4; switch (d->style) { case Qt::DashLine: - dd->dashPattern.reserve(2); - dd->dashPattern << dash << space; + d->dashPattern.reserve(2); + d->dashPattern << dash << space; break; case Qt::DotLine: - dd->dashPattern.reserve(2); - dd->dashPattern << dot << space; + d->dashPattern.reserve(2); + d->dashPattern << dot << space; break; case Qt::DashDotLine: - dd->dashPattern.reserve(4); - dd->dashPattern << dash << space << dot << space; + d->dashPattern.reserve(4); + d->dashPattern << dash << space << dot << space; break; case Qt::DashDotDotLine: - dd->dashPattern.reserve(6); - dd->dashPattern << dash << space << dot << space << dot << space; + d->dashPattern.reserve(6); + d->dashPattern << dash << space << dot << space << dot << space; break; default: break; } } - return dd->dashPattern; + return d->dashPattern; } /*! @@ -487,13 +466,12 @@ void QPen::setDashPattern(const QList<qreal> &pattern) return; detach(); - QPenData *dd = static_cast<QPenData *>(d); - dd->dashPattern = pattern; + d->dashPattern = pattern; d->style = Qt::CustomDashLine; - if ((dd->dashPattern.size() % 2) == 1) { + if ((d->dashPattern.size() % 2) == 1) { qWarning("QPen::setDashPattern: Pattern not of even length"); - dd->dashPattern << 1; + d->dashPattern << 1; } } @@ -505,8 +483,7 @@ void QPen::setDashPattern(const QList<qreal> &pattern) */ qreal QPen::dashOffset() const { - QPenData *dd = static_cast<QPenData *>(d); - return dd->dashOffset; + return d->dashOffset; } /*! Sets the dash offset (the starting point on the dash pattern) for this pen @@ -528,13 +505,12 @@ qreal QPen::dashOffset() const */ void QPen::setDashOffset(qreal offset) { - if (qFuzzyCompare(offset, static_cast<QPenData *>(d)->dashOffset)) + if (qFuzzyCompare(offset, d->dashOffset)) return; detach(); - QPenData *dd = static_cast<QPenData *>(d); - dd->dashOffset = offset; + d->dashOffset = offset; if (d->style != Qt::CustomDashLine) { - dd->dashPattern = dashPattern(); + d->dashPattern = dashPattern(); d->style = Qt::CustomDashLine; } } @@ -547,8 +523,7 @@ void QPen::setDashOffset(qreal offset) */ qreal QPen::miterLimit() const { - const QPenData *dd = static_cast<QPenData *>(d); - return dd->miterLimit; + return d->miterLimit; } /*! @@ -570,8 +545,7 @@ qreal QPen::miterLimit() const void QPen::setMiterLimit(qreal limit) { detach(); - QPenData *dd = static_cast<QPenData *>(d); - dd->miterLimit = limit; + d->miterLimit = limit; } @@ -782,8 +756,7 @@ bool QPen::isSolid() const bool QPen::isCosmetic() const { - QPenData *dd = static_cast<QPenData *>(d); - return (dd->cosmetic == true) || d->width == 0; + return (d->cosmetic == true) || d->width == 0; } @@ -797,8 +770,7 @@ bool QPen::isCosmetic() const void QPen::setCosmetic(bool cosmetic) { detach(); - QPenData *dd = static_cast<QPenData *>(d); - dd->cosmetic = cosmetic; + d->cosmetic = cosmetic; } @@ -825,19 +797,17 @@ void QPen::setCosmetic(bool cosmetic) bool QPen::operator==(const QPen &p) const { - QPenData *dd = static_cast<QPenData *>(d); - QPenData *pdd = static_cast<QPenData *>(p.d); return (p.d == d) || (p.d->style == d->style && p.d->capStyle == d->capStyle && p.d->joinStyle == d->joinStyle && p.d->width == d->width - && pdd->miterLimit == dd->miterLimit + && p.d->miterLimit == d->miterLimit && (d->style != Qt::CustomDashLine - || (qFuzzyCompare(pdd->dashOffset, dd->dashOffset) && - pdd->dashPattern == dd->dashPattern)) + || (qFuzzyCompare(p.d->dashOffset, d->dashOffset) && + p.d->dashPattern == d->dashPattern)) && p.d->brush == d->brush - && pdd->cosmetic == dd->cosmetic); + && p.d->cosmetic == d->cosmetic); } @@ -869,14 +839,13 @@ bool QPen::isDetached() QDataStream &operator<<(QDataStream &s, const QPen &p) { - QPenData *dd = static_cast<QPenData *>(p.d); if (s.version() < 3) { s << (quint8)p.style(); } else if (s.version() < QDataStream::Qt_4_3) { s << (quint8)(uint(p.style()) | uint(p.capStyle()) | uint(p.joinStyle())); } else { s << (quint16)(uint(p.style()) | uint(p.capStyle()) | uint(p.joinStyle())); - s << (bool)(dd->cosmetic); + s << (bool)(p.d->cosmetic); } if (s.version() < 7) { @@ -965,16 +934,15 @@ QDataStream &operator>>(QDataStream &s, QPen &p) } p.detach(); - QPenData *dd = static_cast<QPenData *>(p.d); - dd->width = width; - dd->brush = brush; - dd->style = Qt::PenStyle(style & Qt::MPenStyle); - dd->capStyle = Qt::PenCapStyle(style & Qt::MPenCapStyle); - dd->joinStyle = Qt::PenJoinStyle(style & Qt::MPenJoinStyle); - dd->dashPattern = dashPattern; - dd->miterLimit = miterLimit; - dd->dashOffset = dashOffset; - dd->cosmetic = cosmetic; + p.d->width = width; + p.d->brush = brush; + p.d->style = Qt::PenStyle(style & Qt::MPenStyle); + p.d->capStyle = Qt::PenCapStyle(style & Qt::MPenCapStyle); + p.d->joinStyle = Qt::PenJoinStyle(style & Qt::MPenJoinStyle); + p.d->dashPattern = dashPattern; + p.d->miterLimit = miterLimit; + p.d->dashOffset = dashOffset; + p.d->cosmetic = cosmetic; return s; } diff --git a/src/gui/painting/qpen.h b/src/gui/painting/qpen.h index d8f13df388..3367b96c35 100644 --- a/src/gui/painting/qpen.h +++ b/src/gui/painting/qpen.h @@ -4,6 +4,7 @@ #ifndef QPEN_H #define QPEN_H +#include <QtCore/qshareddata.h> #include <QtGui/qtguiglobal.h> #include <QtGui/qcolor.h> #include <QtGui/qbrush.h> @@ -21,6 +22,8 @@ Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QPen &); Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QPen &); #endif +QT_DECLARE_QESDP_SPECIALIZATION_DTOR_WITH_EXPORT(QPenPrivate, Q_GUI_EXPORT) + class Q_GUI_EXPORT QPen { public: @@ -34,10 +37,9 @@ public: ~QPen(); QPen &operator=(const QPen &pen) noexcept; - QPen(QPen &&other) noexcept - : d(qExchange(other.d, nullptr)) {} + QPen(QPen &&other) noexcept = default; QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_PURE_SWAP(QPen) - void swap(QPen &other) noexcept { qt_ptr_swap(d, other.d); } + void swap(QPen &other) noexcept { d.swap(other.d); } Qt::PenStyle style() const; void setStyle(Qt::PenStyle); @@ -79,15 +81,19 @@ public: operator QVariant() const; bool isDetached(); + private: friend Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QPen &); friend Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QPen &); +public: + using DataPtr = QExplicitlySharedDataPointer<QPenPrivate>; + +private: void detach(); - class QPenPrivate *d; + DataPtr d; public: - typedef QPenPrivate * DataPtr; inline DataPtr &data_ptr() { return d; } }; diff --git a/src/gui/painting/qpen_p.h b/src/gui/painting/qpen_p.h index 39ed024d85..a939c5e4f6 100644 --- a/src/gui/painting/qpen_p.h +++ b/src/gui/painting/qpen_p.h @@ -16,14 +16,15 @@ // #include <QtCore/private/qglobal_p.h> +#include <QtCore/qshareddata.h> QT_BEGIN_NAMESPACE -class QPenPrivate { +class QPenPrivate : public QSharedData +{ public: QPenPrivate(const QBrush &brush, qreal width, Qt::PenStyle, Qt::PenCapStyle, Qt::PenJoinStyle _joinStyle); - QAtomicInt ref; qreal width; QBrush brush; Qt::PenStyle style; diff --git a/src/gui/painting/qpixellayout.cpp b/src/gui/painting/qpixellayout.cpp index 025bb168f5..4f2f0ae13a 100644 --- a/src/gui/painting/qpixellayout.cpp +++ b/src/gui/painting/qpixellayout.cpp @@ -7,6 +7,7 @@ #include "qpixellayout_p.h" #include "qrgba64_p.h" #include <QtCore/private/qsimd_p.h> +#include <QtGui/private/qcmyk_p.h> QT_BEGIN_NAMESPACE @@ -212,8 +213,7 @@ inline void QT_FASTCALL storePixel<QPixelLayout::BPP24>(uchar *dest, int index, template <QPixelLayout::BPP bpp> static inline uint QT_FASTCALL fetchPixel(const uchar *, int) { - Q_UNREACHABLE(); - return 0; + Q_UNREACHABLE_RETURN(0); } template <> @@ -1188,10 +1188,12 @@ static const QRgba64 *QT_FASTCALL fetchRGBA64ToRGBA64PM(QRgba64 *buffer, const u const QRgba64 *s = reinterpret_cast<const QRgba64 *>(src) + index; #ifdef __SSE2__ for (int i = 0; i < count; ++i) { + const auto a = s[i].alpha(); __m128i vs = _mm_loadl_epi64((const __m128i *)(s + i)); __m128i va = _mm_shufflelo_epi16(vs, _MM_SHUFFLE(3, 3, 3, 3)); vs = multiplyAlpha65535(vs, va); _mm_storel_epi64((__m128i *)(buffer + i), vs); + buffer[i].setAlpha(a); } #else for (int i = 0; i < count; ++i) @@ -1656,11 +1658,71 @@ static const QRgba64 *QT_FASTCALL fetchRGBA32FPMToRGBA64PM(QRgba64 *buffer, cons return buffer; } +inline const uint *qt_convertCMYK8888ToARGB32PM(uint *buffer, const uint *src, int count) +{ + UNALIASED_CONVERSION_LOOP(buffer, src, count, [](uint s) { + const QColor color = QCmyk32::fromCmyk32(s).toColor(); + return color.rgba(); + }); + return buffer; +} + +static void QT_FASTCALL convertCMYK8888ToARGB32PM(uint *buffer, int count, const QList<QRgb> *) +{ + qt_convertCMYK8888ToARGB32PM(buffer, buffer, count); +} + +static const QRgba64 *QT_FASTCALL convertCMYK8888ToToRGBA64PM(QRgba64 *buffer, const uint *src, int count, + const QList<QRgb> *, QDitherInfo *) +{ + for (int i = 0; i < count; ++i) + buffer[i] = QCmyk32::fromCmyk32(src[i]).toColor().rgba64(); + return buffer; +} + +static const uint *QT_FASTCALL fetchCMYK8888ToARGB32PM(uint *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const uint *s = reinterpret_cast<const uint *>(src) + index; + for (int i = 0; i < count; ++i) + buffer[i] = QCmyk32::fromCmyk32(s[i]).toColor().rgba(); + return buffer; +} + +static const QRgba64 *QT_FASTCALL fetchCMYK8888ToRGBA64PM(QRgba64 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const uint *s = reinterpret_cast<const uint *>(src) + index; + for (int i = 0; i < count; ++i) + buffer[i] = QCmyk32::fromCmyk32(s[i]).toColor().rgba64(); + return buffer; +} + +static void QT_FASTCALL storeCMYK8888FromARGB32PM(uchar *dest, const uint *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + uint *d = reinterpret_cast<uint *>(dest) + index; + for (int i = 0; i < count; ++i) { + QColor c = qUnpremultiply(src[i]); + d[i] = QCmyk32::fromColor(c).toUint(); + } +} + +static void QT_FASTCALL storeCMYK8888FromRGB32(uchar *dest, const uint *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + uint *d = reinterpret_cast<uint *>(dest) + index; + for (int i = 0; i < count; ++i) { + QColor c = src[i]; + d[i] = QCmyk32::fromColor(c).toUint(); + } +} + // Note: // convertToArgb32() assumes that no color channel is less than 4 bits. // storeRGBFromARGB32PM() assumes that no color channel is more than 8 bits. // QImage::rgbSwapped() assumes that the red and blue color channels have the same number of bits. -QPixelLayout qPixelLayouts[QImage::NImageFormats] = { +QPixelLayout qPixelLayouts[] = { { false, false, QPixelLayout::BPPNone, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }, // Format_Invalid { false, false, QPixelLayout::BPP1MSB, nullptr, convertIndexedToARGB32PM, convertIndexedTo<QRgba64>, @@ -1778,9 +1840,13 @@ QPixelLayout qPixelLayouts[QImage::NImageFormats] = { convertPassThrough, nullptr, fetchRGB32FToRGB32, fetchRGBA32FPMToRGBA64PM, storeRGB32FFromRGB32, storeRGB32FFromRGB32 }, // Format_RGBA32FPx4_Premultiplied + { false, false, QPixelLayout::BPP32, nullptr, + convertCMYK8888ToARGB32PM, convertCMYK8888ToToRGBA64PM, + fetchCMYK8888ToARGB32PM, fetchCMYK8888ToRGBA64PM, + storeCMYK8888FromARGB32PM, storeCMYK8888FromRGB32 }, // Format_CMYK8888 }; -static_assert(sizeof(qPixelLayouts) / sizeof(*qPixelLayouts) == QImage::NImageFormats); +static_assert(std::size(qPixelLayouts) == QImage::NImageFormats); static void QT_FASTCALL convertFromRgb64(uint *dest, const QRgba64 *src, int length) { @@ -1915,7 +1981,15 @@ static void QT_FASTCALL storeRGBA32FPMFromRGBA64PM(uchar *dest, const QRgba64 *s d[i] = qConvertRgb64ToRgbaF32(src[i]); } -ConvertAndStorePixelsFunc64 qStoreFromRGBA64PM[QImage::NImageFormats] = { +static void QT_FASTCALL storeCMYKFromRGBA64PM(uchar *dest, const QRgba64 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + uint *d = reinterpret_cast<uint *>(dest) + index; + for (int i = 0; i < count; ++i) + d[i] = QCmyk32::fromColor(QColor(src[i])).toUint(); +} + +ConvertAndStorePixelsFunc64 qStoreFromRGBA64PM[] = { nullptr, nullptr, nullptr, @@ -1952,8 +2026,11 @@ ConvertAndStorePixelsFunc64 qStoreFromRGBA64PM[QImage::NImageFormats] = { storeRGBX32FFromRGBA64PM, storeRGBA32FFromRGBA64PM, storeRGBA32FPMFromRGBA64PM, + storeCMYKFromRGBA64PM, }; +static_assert(std::size(qStoreFromRGBA64PM) == QImage::NImageFormats); + #if QT_CONFIG(raster_fp) static void QT_FASTCALL convertToRgbaF32(QRgbaFloat32 *dest, const uint *src, int length) { @@ -1999,7 +2076,16 @@ static const QRgbaFloat32 * QT_FASTCALL convertRGB30ToRGBA32F(QRgbaFloat32 *buff return buffer; } -ConvertToFPFunc qConvertToRGBA32F[QImage::NImageFormats] = { +static const QRgbaFloat32 * QT_FASTCALL convertCMYKToRGBA32F(QRgbaFloat32 *buffer, const uint *src, int count, + const QList<QRgb> *, QDitherInfo *) +{ + for (int i = 0; i < count; ++i) + buffer[i] = QRgbaFloat32::fromArgb32(QCmyk32::fromCmyk32(src[i]).toColor().rgba()); + + return buffer; +} + +ConvertToFPFunc qConvertToRGBA32F[] = { nullptr, convertIndexedTo<QRgbaFloat32>, convertIndexedTo<QRgbaFloat32>, @@ -2036,8 +2122,11 @@ ConvertToFPFunc qConvertToRGBA32F[QImage::NImageFormats] = { nullptr, nullptr, nullptr, + convertCMYKToRGBA32F, }; +static_assert(std::size(qConvertToRGBA32F) == QImage::NImageFormats); + static const QRgbaFloat32 *QT_FASTCALL fetchRGBX64ToRGBA32F(QRgbaFloat32 *buffer, const uchar *src, int index, int count, const QList<QRgb> *, QDitherInfo *) { @@ -2102,7 +2191,17 @@ static const QRgbaFloat32 *QT_FASTCALL fetchRGBA32F(QRgbaFloat32 *, const uchar return s; } -FetchAndConvertPixelsFuncFP qFetchToRGBA32F[QImage::NImageFormats] = { +static const QRgbaFloat32 *QT_FASTCALL fetchCMYKToRGBA32F(QRgbaFloat32 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const uint *s = reinterpret_cast<const uint *>(src) + index; + for (int i = 0; i < count; ++i) + buffer[i] = QRgbaFloat32::fromArgb32(QCmyk32::fromCmyk32(s[i]).toColor().rgba()); + + return buffer; +} + +FetchAndConvertPixelsFuncFP qFetchToRGBA32F[] = { nullptr, fetchIndexedToRGBA32F<QPixelLayout::BPP1MSB>, fetchIndexedToRGBA32F<QPixelLayout::BPP1LSB>, @@ -2139,8 +2238,11 @@ FetchAndConvertPixelsFuncFP qFetchToRGBA32F[QImage::NImageFormats] = { fetchRGBA32F, fetchRGBA32FToRGBA32F, fetchRGBA32F, + fetchCMYKToRGBA32F, }; +static_assert(std::size(qFetchToRGBA32F) == QImage::NImageFormats); + static void QT_FASTCALL convertFromRgba32f(uint *dest, const QRgbaFloat32 *src, int length) { for (int i = 0; i < length; ++i) @@ -2227,7 +2329,7 @@ static void QT_FASTCALL storeRGBX16FFromRGBA32F(uchar *dest, const QRgbaFloat32 QRgbaFloat16 *d = reinterpret_cast<QRgbaFloat16 *>(dest) + index; for (int i = 0; i < count; ++i) { auto s = src[i].unpremultiplied(); - d[i] = QRgbaFloat16{ s.r, s.g, s.b, 1.0f }; + d[i] = QRgbaFloat16{ qfloat16(s.r), qfloat16(s.g), qfloat16(s.b), qfloat16(1.0f) }; } } @@ -2237,7 +2339,7 @@ static void QT_FASTCALL storeRGBA16FFromRGBA32F(uchar *dest, const QRgbaFloat32 QRgbaFloat16 *d = reinterpret_cast<QRgbaFloat16 *>(dest) + index; for (int i = 0; i < count; ++i) { auto s = src[i].unpremultiplied(); - d[i] = QRgbaFloat16{ s.r, s.g, s.b, s.a }; + d[i] = QRgbaFloat16{ qfloat16(s.r), qfloat16(s.g), qfloat16(s.b), qfloat16(s.a) }; } } @@ -2277,7 +2379,17 @@ static void QT_FASTCALL storeRGBA32FPMFromRGBA32F(uchar *dest, const QRgbaFloat3 } } -ConvertAndStorePixelsFuncFP qStoreFromRGBA32F[QImage::NImageFormats] = { +static void QT_FASTCALL storeCMYKFromRGBA32F(uchar *dest, const QRgbaFloat32 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + uint *d = reinterpret_cast<uint *>(dest) + index; + for (int i = 0; i < count; ++i) { + // Yikes, this really needs enablers in QColor and friends + d[i] = QCmyk32::fromColor(QColor(src[i].toArgb32())).toUint(); + } +} + +ConvertAndStorePixelsFuncFP qStoreFromRGBA32F[] = { nullptr, nullptr, nullptr, @@ -2314,7 +2426,11 @@ ConvertAndStorePixelsFuncFP qStoreFromRGBA32F[QImage::NImageFormats] = { storeRGBX32FFromRGBA32F, storeRGBA32FFromRGBA32F, storeRGBA32FPMFromRGBA32F, + storeCMYKFromRGBA32F, }; + +static_assert(std::size(qStoreFromRGBA32F) == QImage::NImageFormats); + #endif // QT_CONFIG(raster_fp) QT_END_NAMESPACE diff --git a/src/gui/painting/qpixellayout_p.h b/src/gui/painting/qpixellayout_p.h index 45f6c15365..14f19f4e74 100644 --- a/src/gui/painting/qpixellayout_p.h +++ b/src/gui/painting/qpixellayout_p.h @@ -321,12 +321,12 @@ struct QPixelLayout extern ConvertAndStorePixelsFunc64 qStoreFromRGBA64PM[QImage::NImageFormats]; #if QT_CONFIG(raster_fp) -extern ConvertToFPFunc qConvertToRGBA32F[QImage::NImageFormats]; -extern FetchAndConvertPixelsFuncFP qFetchToRGBA32F[QImage::NImageFormats]; -extern ConvertAndStorePixelsFuncFP qStoreFromRGBA32F[QImage::NImageFormats]; +extern ConvertToFPFunc qConvertToRGBA32F[]; +extern FetchAndConvertPixelsFuncFP qFetchToRGBA32F[]; +extern ConvertAndStorePixelsFuncFP qStoreFromRGBA32F[]; #endif -extern QPixelLayout qPixelLayouts[QImage::NImageFormats]; +extern QPixelLayout qPixelLayouts[]; extern MemRotateFunc qMemRotateFunctions[QPixelLayout::BPPCount][3]; diff --git a/src/gui/painting/qplatformbackingstore.cpp b/src/gui/painting/qplatformbackingstore.cpp index 74c8ea30ac..f7c4df40c8 100644 --- a/src/gui/painting/qplatformbackingstore.cpp +++ b/src/gui/painting/qplatformbackingstore.cpp @@ -37,6 +37,7 @@ struct QBackingstoreTextureInfo { void *source; // may be null QRhiTexture *texture; + QRhiTexture *textureExtra; QRect rect; QRect clipRect; QPlatformTextureList::Flags flags; @@ -68,7 +69,7 @@ QPlatformTextureList::~QPlatformTextureList() int QPlatformTextureList::count() const { Q_D(const QPlatformTextureList); - return d->textures.count(); + return d->textures.size(); } QRhiTexture *QPlatformTextureList::texture(int index) const @@ -77,6 +78,12 @@ QRhiTexture *QPlatformTextureList::texture(int index) const return d->textures.at(index).texture; } +QRhiTexture *QPlatformTextureList::textureExtra(int index) const +{ + Q_D(const QPlatformTextureList); + return d->textures.at(index).textureExtra; +} + void *QPlatformTextureList::source(int index) { Q_D(const QPlatformTextureList); @@ -123,6 +130,22 @@ void QPlatformTextureList::appendTexture(void *source, QRhiTexture *texture, con QBackingstoreTextureInfo bi; bi.source = source; bi.texture = texture; + bi.textureExtra = nullptr; + bi.rect = geometry; + bi.clipRect = clipRect; + bi.flags = flags; + d->textures.append(bi); +} + +void QPlatformTextureList::appendTexture(void *source, QRhiTexture *textureLeft, QRhiTexture *textureRight, const QRect &geometry, + const QRect &clipRect, Flags flags) +{ + Q_D(QPlatformTextureList); + + QBackingstoreTextureInfo bi; + bi.source = source; + bi.texture = textureLeft; + bi.textureExtra = textureRight; bi.rect = geometry; bi.clipRect = clipRect; bi.flags = flags; @@ -181,13 +204,14 @@ void QPlatformBackingStore::flush(QWindow *window, const QRegion ®ion, const \sa flush() */ QPlatformBackingStore::FlushResult QPlatformBackingStore::rhiFlush(QWindow *window, + qreal sourceDevicePixelRatio, const QRegion ®ion, const QPoint &offset, QPlatformTextureList *textures, bool translucentBackground) { return d_ptr->compositor.flush(this, d_ptr->rhiSupport.rhi(), d_ptr->rhiSupport.swapChainForWindow(window), - window, region, offset, textures, translucentBackground); + window, sourceDevicePixelRatio, region, offset, textures, translucentBackground); } /*! @@ -355,6 +379,7 @@ void QPlatformBackingStore::graphicsDeviceReportedLost() return; qWarning("Rhi backingstore: graphics device lost, attempting to reinitialize"); + d_ptr->compositor.reset(); d_ptr->rhiSupport.reset(); d_ptr->rhiSupport.create(); if (!d_ptr->rhiSupport.rhi()) diff --git a/src/gui/painting/qplatformbackingstore.h b/src/gui/painting/qplatformbackingstore.h index bfb40fe5e0..1d55e9ab6a 100644 --- a/src/gui/painting/qplatformbackingstore.h +++ b/src/gui/painting/qplatformbackingstore.h @@ -23,7 +23,7 @@ QT_BEGIN_NAMESPACE -Q_GUI_EXPORT Q_DECLARE_LOGGING_CATEGORY(lcQpaBackingStore) +Q_DECLARE_EXPORTED_LOGGING_CATEGORY(lcQpaBackingStore, Q_GUI_EXPORT) class QRegion; class QRect; @@ -36,7 +36,6 @@ class QPlatformGraphicsBuffer; class QRhi; class QRhiTexture; class QRhiResourceUpdateBatch; -class QRhiSwapChain; struct Q_GUI_EXPORT QPlatformBackingStoreRhiConfig { @@ -45,6 +44,7 @@ struct Q_GUI_EXPORT QPlatformBackingStoreRhiConfig Metal, Vulkan, D3D11, + D3D12, Null }; @@ -66,22 +66,10 @@ struct Q_GUI_EXPORT QPlatformBackingStoreRhiConfig bool isDebugLayerEnabled() const { return m_debugLayer; } void setDebugLayer(bool enable) { m_debugLayer = enable; } - QByteArrayList instanceExtensions() const { return m_instanceExtensions; } - void setInstanceExtensions(const QByteArrayList &e) { m_instanceExtensions = e; } - - QByteArrayList instanceLayers() const { return m_instanceLayers; } - void setInstanceLayers(const QByteArrayList &e) { m_instanceLayers = e; } - - QByteArrayList deviceExtensions() const { return m_deviceExtensions; } - void setDeviceExtensions(const QByteArrayList &e) { m_deviceExtensions = e; } - private: bool m_enable; Api m_api = Null; bool m_debugLayer = false; - QByteArrayList m_instanceExtensions; - QByteArrayList m_instanceLayers; - QByteArrayList m_deviceExtensions; friend bool operator==(const QPlatformBackingStoreRhiConfig &a, const QPlatformBackingStoreRhiConfig &b); }; @@ -89,10 +77,7 @@ inline bool operator==(const QPlatformBackingStoreRhiConfig &a, const QPlatformB { return a.m_enable == b.m_enable && a.m_api == b.m_api - && a.m_debugLayer == b.m_debugLayer - && a.m_instanceExtensions == b.m_instanceExtensions - && a.m_instanceLayers == b.m_instanceLayers - && a.m_deviceExtensions == b.m_deviceExtensions; + && a.m_debugLayer == b.m_debugLayer; } inline bool operator!=(const QPlatformBackingStoreRhiConfig &a, const QPlatformBackingStoreRhiConfig &b) @@ -108,7 +93,8 @@ public: enum Flag { StacksOnTop = 0x01, TextureIsSrgb = 0x02, - NeedsPremultipliedAlphaBlending = 0x04 + NeedsPremultipliedAlphaBlending = 0x04, + MirrorVertically = 0x08 }; Q_DECLARE_FLAGS(Flags, Flag) @@ -118,6 +104,7 @@ public: int count() const; bool isEmpty() const { return count() == 0; } QRhiTexture *texture(int index) const; + QRhiTexture *textureExtra(int index) const; QRect geometry(int index) const; QRect clipRect(int index) const; void *source(int index); @@ -127,6 +114,9 @@ public: void appendTexture(void *source, QRhiTexture *texture, const QRect &geometry, const QRect &clipRect = QRect(), Flags flags = { }); + + void appendTexture(void *source, QRhiTexture *textureLeft, QRhiTexture *textureRight, const QRect &geometry, + const QRect &clipRect = QRect(), Flags flags = { }); void clear(); Q_SIGNALS: @@ -154,6 +144,7 @@ public: virtual void flush(QWindow *window, const QRegion ®ion, const QPoint &offset); virtual FlushResult rhiFlush(QWindow *window, + qreal sourceDevicePixelRatio, const QRegion ®ion, const QPoint &offset, QPlatformTextureList *textures, @@ -182,7 +173,6 @@ public: void setRhiConfig(const QPlatformBackingStoreRhiConfig &config); QRhi *rhi() const; - QRhiSwapChain *rhiSwapChain() const; void surfaceAboutToBeDestroyed(); void graphicsDeviceReportedLost(); diff --git a/src/gui/painting/qpolygon.cpp b/src/gui/painting/qpolygon.cpp index 99d67599ed..d615245eb4 100644 --- a/src/gui/painting/qpolygon.cpp +++ b/src/gui/painting/qpolygon.cpp @@ -419,12 +419,7 @@ QRect QPolygon::boundingRect() const #ifndef QT_NO_DEBUG_STREAM QDebug operator<<(QDebug dbg, const QPolygon &a) { - QDebugStateSaver saver(dbg); - dbg.nospace() << "QPolygon("; - for (int i = 0; i < a.count(); ++i) - dbg.nospace() << a.at(i); - dbg.nospace() << ')'; - return dbg; + return QtPrivate::printSequentialContainer(dbg, "QPolygon", a); } #endif @@ -702,13 +697,7 @@ QDataStream &operator>>(QDataStream &s, QPolygon &a) QDataStream &operator<<(QDataStream &s, const QPolygonF &a) { - quint32 len = a.size(); - uint i; - - s << len; - for (i = 0; i < len; ++i) - s << a.at(i); - return s; + return s << static_cast<const QList<QPointF> &>(a); } /*! @@ -723,29 +712,14 @@ QDataStream &operator<<(QDataStream &s, const QPolygonF &a) QDataStream &operator>>(QDataStream &s, QPolygonF &a) { - quint32 len; - uint i; - - s >> len; - a.reserve(a.size() + (int)len); - QPointF p; - for (i = 0; i < len; ++i) { - s >> p; - a.insert(i, p); - } - return s; + return s >> static_cast<QList<QPointF> &>(a); } #endif //QT_NO_DATASTREAM #ifndef QT_NO_DEBUG_STREAM QDebug operator<<(QDebug dbg, const QPolygonF &a) { - QDebugStateSaver saver(dbg); - dbg.nospace() << "QPolygonF("; - for (int i = 0; i < a.count(); ++i) - dbg.nospace() << a.at(i); - dbg.nospace() << ')'; - return dbg; + return QtPrivate::printSequentialContainer(dbg, "QPolygonF", a); } #endif diff --git a/src/gui/painting/qrasterbackingstore.cpp b/src/gui/painting/qrasterbackingstore.cpp index c0df8088d4..3b3ef2fd2e 100644 --- a/src/gui/painting/qrasterbackingstore.cpp +++ b/src/gui/painting/qrasterbackingstore.cpp @@ -67,7 +67,7 @@ void QRasterBackingStore::beginPaint(const QRegion ®ion) if (m_image.devicePixelRatio() != nativeWindowDevicePixelRatio || m_image.size() != effectiveBufferSize) { m_image = QImage(effectiveBufferSize, format()); m_image.setDevicePixelRatio(nativeWindowDevicePixelRatio); - if (m_image.format() == QImage::Format_ARGB32_Premultiplied) + if (m_image.hasAlphaChannel()) m_image.fill(Qt::transparent); } diff --git a/src/gui/painting/qrasterizer.cpp b/src/gui/painting/qrasterizer.cpp index 8a3e46e58b..cd9d3ba4d0 100644 --- a/src/gui/painting/qrasterizer.cpp +++ b/src/gui/painting/qrasterizer.cpp @@ -1064,28 +1064,26 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width, while (x <= leftMax) { QScFixed excluded = 0; - if (yFP <= iLeftFP) + if (yFP <= iLeftFP && rowBottomLeft > rowTop) excluded += intersectPixelFP(x, rowTop, rowBottomLeft, bottomLeftIntersectAf, topLeftIntersectAf, topLeftSlopeFP, invTopLeftSlopeFP); - if (yFP >= iLeftFP) + if (yFP >= iLeftFP && rowBottom > rowTopLeft) excluded += intersectPixelFP(x, rowTopLeft, rowBottom, topLeftIntersectBf, bottomLeftIntersectBf, bottomLeftSlopeFP, invBottomLeftSlopeFP); - if (x >= rightMin) { - if (yFP <= iRightFP) + if (yFP <= iRightFP && rowBottomRight > rowTop) excluded += (rowBottomRight - rowTop) - intersectPixelFP(x, rowTop, rowBottomRight, topRightIntersectAf, bottomRightIntersectAf, topRightSlopeFP, invTopRightSlopeFP); - if (yFP >= iRightFP) + if (yFP >= iRightFP && rowBottom > rowTopRight) excluded += (rowBottom - rowTopRight) - intersectPixelFP(x, rowTopRight, rowBottom, bottomRightIntersectBf, topRightIntersectBf, bottomRightSlopeFP, invBottomRightSlopeFP); } - if (excluded > QScFixedFactor) - excluded = excluded % QScFixedFactor; + Q_ASSERT(excluded >= 0 && excluded <= rowHeight); QScFixed coverage = rowHeight - excluded; buffer.addSpan(x, 1, QScFixedToInt(yFP), QScFixedToInt(255 * coverage)); @@ -1098,17 +1096,16 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width, } while (x <= rightMax) { QScFixed excluded = 0; - if (yFP <= iRightFP) + if (yFP <= iRightFP && rowBottomRight > rowTop) excluded += (rowBottomRight - rowTop) - intersectPixelFP(x, rowTop, rowBottomRight, topRightIntersectAf, bottomRightIntersectAf, topRightSlopeFP, invTopRightSlopeFP); - if (yFP >= iRightFP) + if (yFP >= iRightFP && rowBottom > rowTopRight) excluded += (rowBottom - rowTopRight) - intersectPixelFP(x, rowTopRight, rowBottom, bottomRightIntersectBf, topRightIntersectBf, bottomRightSlopeFP, invBottomRightSlopeFP); - if (excluded > QScFixedFactor) - excluded = excluded % QScFixedFactor; + Q_ASSERT(excluded >= 0 && excluded <= rowHeight); QScFixed coverage = rowHeight - excluded; buffer.addSpan(x, 1, QScFixedToInt(yFP), QScFixedToInt(255 * coverage)); diff --git a/src/gui/painting/qregion.cpp b/src/gui/painting/qregion.cpp index 7d912b29e5..8b712ee46d 100644 --- a/src/gui/painting/qregion.cpp +++ b/src/gui/painting/qregion.cpp @@ -51,7 +51,7 @@ QT_BEGIN_NAMESPACE contains() a QPoint or QRect. The bounding rectangle can be found with boundingRect(). - Iteration over the region (with begin(), end(), or C++11 + Iteration over the region (with begin(), end(), or ranged-for loops) gives a decomposition of the region into rectangles. @@ -636,7 +636,7 @@ bool QRegion::intersects(const QRegion ®ion) const */ -#if !defined (Q_OS_UNIX) && !defined (Q_OS_WIN) || defined(Q_CLANG_QDOC) +#if !defined (Q_OS_UNIX) && !defined (Q_OS_WIN) || defined(Q_QDOC) /* \overload \since 4.4 @@ -3191,8 +3191,7 @@ static void CreateETandAET(int count, const QPoint *pts, int iSLLBlock = 0; int dy; - if (count < 2) - return; + Q_ASSERT(count > 1); /* * initialize the Active Edge Table @@ -3538,7 +3537,7 @@ static QRegionPrivate *PolygonRegion(const QPoint *Pts, int Count, int rule) POINTBLOCK *tmpPtBlock; int numFullPtBlocks = 0; - Q_ASSUME(Count > 1); + Q_ASSERT(Count > 1); region = new QRegionPrivate; @@ -3818,7 +3817,7 @@ QRegion::QRegion(const QRect &r, RegionType t) QRegion::QRegion(const QPolygon &a, Qt::FillRule fillRule) { - if (a.count() > 2) { + if (a.size() > 2) { QRegionPrivate *qt_rgn = PolygonRegion(a.constData(), a.size(), fillRule == Qt::WindingFill ? WindingRule : EvenOddRule); if (qt_rgn) { diff --git a/src/gui/painting/qregion.h b/src/gui/painting/qregion.h index c946287411..b0051b6067 100644 --- a/src/gui/painting/qregion.h +++ b/src/gui/painting/qregion.h @@ -34,7 +34,7 @@ public: QRegion(const QPolygon &pa, Qt::FillRule fillRule = Qt::OddEvenFill); QRegion(const QRegion ®ion); QRegion(QRegion &&other) noexcept - : d(qExchange(other.d, const_cast<QRegionData*>(&shared_empty))) {} + : d(std::exchange(other.d, const_cast<QRegionData*>(&shared_empty))) {} QRegion(const QBitmap &bitmap); ~QRegion(); QRegion &operator=(const QRegion &); diff --git a/src/gui/painting/qrgba64_p.h b/src/gui/painting/qrgba64_p.h index e848ae0148..ae8b6fd8cb 100644 --- a/src/gui/painting/qrgba64_p.h +++ b/src/gui/painting/qrgba64_p.h @@ -81,18 +81,22 @@ static inline QRgba64 multiplyAlpha65535(QRgba64 rgba64, uint alpha65535) #endif } +#if defined(__SSE2__) || defined(__ARM_NEON__) template<typename T> static inline T Q_DECL_VECTORCALL multiplyAlpha255(T rgba64, uint alpha255) { -#if defined(__SSE2__) || defined(__ARM_NEON__) return multiplyAlpha65535(rgba64, alpha255 * 257); +} #else +template<typename T> +static inline T multiplyAlpha255(T rgba64, uint alpha255) +{ return QRgba64::fromRgba64(qt_div_255(rgba64.red() * alpha255), qt_div_255(rgba64.green() * alpha255), qt_div_255(rgba64.blue() * alpha255), qt_div_255(rgba64.alpha() * alpha255)); -#endif } +#endif #if defined __SSE2__ static inline __m128i Q_DECL_VECTORCALL interpolate255(__m128i x, uint alpha1, __m128i y, uint alpha2) diff --git a/src/gui/painting/qrgbafloat.h b/src/gui/painting/qrgbafloat.h index 04b2115399..da74328f71 100644 --- a/src/gui/painting/qrgbafloat.h +++ b/src/gui/painting/qrgbafloat.h @@ -19,7 +19,13 @@ class alignas(sizeof(F) * 4) QRgbaFloat static_assert(std::is_same<F, qfloat16>::value || std::is_same<F, float>::value); public: using Type = F; +#if defined(__AVX512FP16__) && QFLOAT16_IS_NATIVE + // AVX512FP16 has multiplication instructions + using FastType = F; +#else + // use FP32 for multiplications using FastType = float; +#endif F r; F g; F b; @@ -28,21 +34,23 @@ public: static constexpr QRgbaFloat fromRgba64(quint16 red, quint16 green, quint16 blue, quint16 alpha) { + constexpr FastType scale = FastType(1.0f / 65535.0f); return QRgbaFloat{ - red * (1.0f / 65535.0f), - green * (1.0f / 65535.0f), - blue * (1.0f / 65535.0f), - alpha * (1.0f / 65535.0f) }; + F(red * scale), + F(green * scale), + F(blue * scale), + F(alpha * scale) }; } static constexpr QRgbaFloat fromRgba(quint8 red, quint8 green, quint8 blue, quint8 alpha) { + constexpr FastType scale = FastType(1.0f / 255.0f); return QRgbaFloat{ - red * (1.0f / 255.0f), - green * (1.0f / 255.0f), - blue * (1.0f / 255.0f), - alpha * (1.0f / 255.0f) }; + F(red * scale), + F(green * scale), + F(blue * scale), + F(alpha * scale) }; } static constexpr QRgbaFloat fromArgb32(uint rgb) @@ -50,36 +58,36 @@ public: return fromRgba(quint8(rgb >> 16), quint8(rgb >> 8), quint8(rgb), quint8(rgb >> 24)); } - constexpr bool isOpaque() const { return a >= 1.0f; } - constexpr bool isTransparent() const { return a <= 0.0f; } - - constexpr FastType red() const { return r; } - constexpr FastType green() const { return g; } - constexpr FastType blue() const { return b; } - constexpr FastType alpha() const { return a; } - void setRed(FastType _red) { r = _red; } - void setGreen(FastType _green) { g = _green; } - void setBlue(FastType _blue) { b = _blue; } - void setAlpha(FastType _alpha) { a = _alpha; } - - constexpr FastType redNormalized() const { return std::clamp(static_cast<FastType>(r), 0.0f, 1.0f); } - constexpr FastType greenNormalized() const { return std::clamp(static_cast<FastType>(g), 0.0f, 1.0f); } - constexpr FastType blueNormalized() const { return std::clamp(static_cast<FastType>(b), 0.0f, 1.0f); } - constexpr FastType alphaNormalized() const { return std::clamp(static_cast<FastType>(a), 0.0f, 1.0f); } - - constexpr quint8 red8() const { return std::lround(redNormalized() * 255.0f); } - constexpr quint8 green8() const { return std::lround(greenNormalized() * 255.0f); } - constexpr quint8 blue8() const { return std::lround(blueNormalized() * 255.0f); } - constexpr quint8 alpha8() const { return std::lround(alphaNormalized() * 255.0f); } + constexpr bool isOpaque() const { return a >= FastType(1.0f); } + constexpr bool isTransparent() const { return a <= FastType(0.0f); } + + constexpr float red() const { return r; } + constexpr float green() const { return g; } + constexpr float blue() const { return b; } + constexpr float alpha() const { return a; } + void setRed(float _red) { r = F(_red); } + void setGreen(float _green) { g = F(_green); } + void setBlue(float _blue) { b = F(_blue); } + void setAlpha(float _alpha) { a = F(_alpha); } + + constexpr float redNormalized() const { return clamp01(r); } + constexpr float greenNormalized() const { return clamp01(g); } + constexpr float blueNormalized() const { return clamp01(b); } + constexpr float alphaNormalized() const { return clamp01(a); } + + constexpr quint8 red8() const { return qRound(redNormalized() * FastType(255.0f)); } + constexpr quint8 green8() const { return qRound(greenNormalized() * FastType(255.0f)); } + constexpr quint8 blue8() const { return qRound(blueNormalized() * FastType(255.0f)); } + constexpr quint8 alpha8() const { return qRound(alphaNormalized() * FastType(255.0f)); } constexpr uint toArgb32() const { return uint((alpha8() << 24) | (red8() << 16) | (green8() << 8) | blue8()); } - constexpr quint16 red16() const { return std::lround(redNormalized() * 65535.0f); } - constexpr quint16 green16() const { return std::lround(greenNormalized() * 65535.0f); } - constexpr quint16 blue16() const { return std::lround(blueNormalized() * 65535.0f); } - constexpr quint16 alpha16() const { return std::lround(alphaNormalized() * 65535.0f); } + constexpr quint16 red16() const { return qRound(redNormalized() * FastType(65535.0f)); } + constexpr quint16 green16() const { return qRound(greenNormalized() * FastType(65535.0f)); } + constexpr quint16 blue16() const { return qRound(blueNormalized() * FastType(65535.0f)); } + constexpr quint16 alpha16() const { return qRound(alphaNormalized() * FastType(65535.0f)); } constexpr Q_ALWAYS_INLINE QRgbaFloat premultiplied() const { @@ -87,12 +95,26 @@ public: } constexpr Q_ALWAYS_INLINE QRgbaFloat unpremultiplied() const { - if (a <= 0.0f) - return QRgbaFloat{0.0f, 0.0f, 0.0f, 0.0f}; - if (a >= 1.0f) + if (a <= F{0.0f}) + return QRgbaFloat{}; // default-initialization: zeroes + if (a >= F{1.0f}) return *this; const FastType ia = 1.0f / a; - return QRgbaFloat{r * ia, g * ia, b * ia, a}; + return QRgbaFloat{F(r * ia), F(g * ia), F(b * ia), F(a)}; + } + constexpr bool operator==(QRgbaFloat f) const + { + return r == f.r && g == f.g && b == f.b && a == f.a; + } + constexpr bool operator!=(QRgbaFloat f) const + { + return !(*this == f); + } + +private: + constexpr static FastType clamp01(Type f) + { + return std::clamp(FastType(f), FastType(0.0f), FastType(1.0f)); } }; diff --git a/src/gui/painting/qrgbafloat.qdoc b/src/gui/painting/qrgbafloat.qdoc index f41064df38..3ec0d209f4 100644 --- a/src/gui/painting/qrgbafloat.qdoc +++ b/src/gui/painting/qrgbafloat.qdoc @@ -33,7 +33,7 @@ */ /*! - \fn template<typename F> QRgbaFloat<F>::fromRgba64(quint16 r, quint16 g, quint16 b, quint16 a) + \fn template<typename F> QRgbaFloat QRgbaFloat<F>::fromRgba64(quint16 red, quint16 green, quint16 blue, quint16 alpha) Constructs a QRgbaFloat value from the four 16-bit integer color channels \a red, \a green, \a blue and \a alpha. @@ -41,7 +41,7 @@ */ /*! - \fn template<typename F> QRgbaFloat<F>::fromRgba(quint8 red, quint8 green, quint8 blue, quint8 alpha) + \fn template<typename F> QRgbaFloat QRgbaFloat<F>::fromRgba(quint8 red, quint8 green, quint8 blue, quint8 alpha) Constructs a QRgbaFloat value from the four 8-bit color channels \a red, \a green, \a blue and \a alpha. @@ -49,7 +49,7 @@ */ /*! - \fn template<typename F> QRgbaFloat<F>::fromArgb32(uint rgb) + \fn template<typename F> QRgbaFloat QRgbaFloat<F>::fromArgb32(uint rgb) Constructs a QRgbaFloat value from the 32bit ARGB value \a rgb. @@ -81,7 +81,7 @@ */ /*! - \fn template<typename F> void QRgbaFloat<F>::setRed(QRgbaFloat::FastType red) + \fn template<typename F> void QRgbaFloat<F>::setRed(float red) Sets the red color component of this color to \a red. @@ -97,7 +97,7 @@ */ /*! - \fn template<typename F> void QRgbaFloat<F>::setGreen(QRgbaFloat::FastType green) + \fn template<typename F> void QRgbaFloat<F>::setGreen(float green) Sets the green color component of this color to \a green. @@ -113,7 +113,7 @@ */ /*! - \fn template<typename F> void QRgbaFloat<F>::setBlue(QRgbaFloat::FastType blue) + \fn template<typename F> void QRgbaFloat<F>::setBlue(float blue) Sets the blue color component of this color to \a blue. @@ -129,7 +129,7 @@ */ /*! - \fn template<typename F> void QRgbaFloat<F>::setAlpha(QRgbaFloat::FastType alpha) + \fn template<typename F> void QRgbaFloat<F>::setAlpha(float alpha) Sets the alpha of this color to \a alpha. diff --git a/src/gui/painting/qrhibackingstore.cpp b/src/gui/painting/qrhibackingstore.cpp index 71b5ccf6cf..586dfb44a4 100644 --- a/src/gui/painting/qrhibackingstore.cpp +++ b/src/gui/painting/qrhibackingstore.cpp @@ -2,6 +2,7 @@ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only #include "qrhibackingstore_p.h" +#include <private/qimage_p.h> QT_BEGIN_NAMESPACE @@ -14,17 +15,24 @@ QRhiBackingStore::~QRhiBackingStore() { } -void QRhiBackingStore::flush(QWindow *window, const QRegion ®ion, const QPoint &offset) +void QRhiBackingStore::flush(QWindow *flushedWindow, const QRegion ®ion, const QPoint &offset) { Q_UNUSED(region); Q_UNUSED(offset); - if (window != this->window()) + if (flushedWindow->surfaceType() != window()->surfaceType()) { + qWarning() << "Cannot flush child window" << flushedWindow + << "with surface type" << flushedWindow->surfaceType() << ";" + << "Must match" << window()->surfaceType() << "of" << window(); + + // FIXME: Support different surface types by not tying the + // RHI config to the backing store itself (per window config). return; + } if (!rhi()) { QPlatformBackingStoreRhiConfig rhiConfig; - switch (window->surfaceType()) { + switch (window()->surfaceType()) { case QSurface::OpenGLSurface: rhiConfig.setApi(QPlatformBackingStoreRhiConfig::OpenGL); break; @@ -40,7 +48,21 @@ void QRhiBackingStore::flush(QWindow *window, const QRegion ®ion, const QPoin static QPlatformTextureList emptyTextureList; bool translucentBackground = m_image.hasAlphaChannel(); - rhiFlush(window, region, offset, &emptyTextureList, translucentBackground); + rhiFlush(flushedWindow, flushedWindow->devicePixelRatio(), + region, offset, &emptyTextureList, translucentBackground); +} + +QImage::Format QRhiBackingStore::format() const +{ + QImage::Format fmt = QRasterBackingStore::format(); + + // With render-to-texture widgets and QRhi-based flushing the backingstore + // image must have an alpha channel. Hence upgrading the format. Matches + // what other platforms (Windows, xcb) do. + if (QImage::toPixelFormat(fmt).alphaUsage() != QPixelFormat::UsesAlpha) + fmt = qt_maybeDataCompatibleAlphaVersion(fmt); + + return fmt; } QT_END_NAMESPACE diff --git a/src/gui/painting/qrhibackingstore_p.h b/src/gui/painting/qrhibackingstore_p.h index 95778fa74c..f222db860f 100644 --- a/src/gui/painting/qrhibackingstore_p.h +++ b/src/gui/painting/qrhibackingstore_p.h @@ -26,6 +26,7 @@ public: ~QRhiBackingStore(); void flush(QWindow *window, const QRegion ®ion, const QPoint &offset) override; + QImage::Format format() const override; }; QT_END_NAMESPACE diff --git a/src/gui/painting/qt_attribution.json b/src/gui/painting/qt_attribution.json index e2326a56c1..33ed2fd5c7 100644 --- a/src/gui/painting/qt_attribution.json +++ b/src/gui/painting/qt_attribution.json @@ -4,13 +4,13 @@ "Name": "Anti-aliasing rasterizer from FreeType 2", "QDocModule": "qtgui", "QtUsage": "Used in Qt GUI.", - "Path": "qgrayraster.c", + "Files": "qgrayraster.c", "Description": "FreeType is a freely available software library to render fonts.", "Homepage": "http://www.freetype.org", "License": "Freetype Project License or GNU General Public License v2.0 only", - "LicenseId": "FTL or GPL-2.0", - "LicenseFile": "../../3rdparty/freetype/docs/LICENSE.TXT", + "LicenseId": "FTL OR GPL-2.0-only", + "LicenseFile": "../../3rdparty/freetype/LICENSE.txt", "Copyright": "Copyright 2000-2016 by David Turner, Robert Wilhelm, and Werner Lemberg." }, { @@ -24,9 +24,9 @@ "LicenseId": "BSD-2-Clause AND Imlib2", "License": "BSD 2-clause \"Simplified\" License and Imlib2 License", "LicenseFile": "QIMAGETRANSFORM_LICENSE.txt", - "Copyright": "Copyright (C) 2004, 2005 Daniel M. Duley. - (C) Carsten Haitzler and various contributors. - (C) Willem Monsuwe <willem@stack.nl>" + "Copyright": ["Copyright (C) 2004, 2005 Daniel M. Duley.", + "(C) Carsten Haitzler and various contributors.", + "(C) Willem Monsuwe <willem@stack.nl>"] }, { "Id": "xserverhelper", @@ -40,7 +40,7 @@ "License": "X11 License and Historical Permission Notice and Disclaimer", "LicenseId": "X11 AND HPND", "LicenseFile": "XCONSORTIUM_LICENSE.txt", - "Copyright": "Copyright (c) 1987, 1988 X Consortium -Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts." + "Copyright": ["Copyright (c) 1987, 1988 X Consortium", + "Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts."] } ] diff --git a/src/gui/painting/qt_mips_asm_dsp_p.h b/src/gui/painting/qt_mips_asm_dsp_p.h index 0b54b88934..6b33285f32 100644 --- a/src/gui/painting/qt_mips_asm_dsp_p.h +++ b/src/gui/painting/qt_mips_asm_dsp_p.h @@ -19,7 +19,7 @@ #pragma qt_sync_stop_processing #endif -#ifndef Q_CLANG_QDOC +#ifndef Q_QDOC #define zero $0 #define AT $1 #define v0 $2 diff --git a/src/gui/painting/qtextureglyphcache.cpp b/src/gui/painting/qtextureglyphcache.cpp index 215eb75e32..70d70e342a 100644 --- a/src/gui/painting/qtextureglyphcache.cpp +++ b/src/gui/painting/qtextureglyphcache.cpp @@ -57,13 +57,14 @@ int QTextureGlyphCache::calculateSubPixelPositionCount(glyph_t glyph) const } bool QTextureGlyphCache::populate(QFontEngine *fontEngine, - int numGlyphs, + qsizetype numGlyphs, const glyph_t *glyphs, const QFixedPoint *positions, - QPainter::RenderHints renderHints) + QPainter::RenderHints renderHints, + bool includeGlyphCacheScale) { #ifdef CACHE_DEBUG - printf("Populating with %d glyphs\n", numGlyphs); + printf("Populating with %lld glyphs\n", static_cast<long long>(numGlyphs)); qDebug() << " -> current transformation: " << m_transform; #endif @@ -78,7 +79,7 @@ bool QTextureGlyphCache::populate(QFontEngine *fontEngine, if (!supportsSubPixelPositions) { fontEngine->m_subPixelPositionCount = 1; } else { - int i = 0; + qsizetype i = 0; while (fontEngine->m_subPixelPositionCount == 0 && i < numGlyphs) fontEngine->m_subPixelPositionCount = calculateSubPixelPositionCount(glyphs[i++]); } @@ -89,16 +90,23 @@ bool QTextureGlyphCache::populate(QFontEngine *fontEngine, m_cy = padding; } + qreal glyphCacheScaleX = transform().m11(); + qreal glyphCacheScaleY = transform().m22(); + QHash<GlyphAndSubPixelPosition, Coord> listItemCoordinates; int rowHeight = 0; // check each glyph for its metrics and get the required rowHeight. - for (int i=0; i < numGlyphs; ++i) { + for (qsizetype i = 0; i < numGlyphs; ++i) { const glyph_t glyph = glyphs[i]; QFixedPoint subPixelPosition; if (supportsSubPixelPositions) { QFixedPoint pos = positions != nullptr ? positions[i] : QFixedPoint(); + if (includeGlyphCacheScale) { + pos = QFixedPoint(QFixed::fromReal(pos.x.toReal() * glyphCacheScaleX), + QFixed::fromReal(pos.y.toReal() * glyphCacheScaleY)); + } subPixelPosition = fontEngine->subPixelPositionFor(pos); if (!verticalSubPixelPositions) subPixelPosition.y = 0; diff --git a/src/gui/painting/qtextureglyphcache_p.h b/src/gui/painting/qtextureglyphcache_p.h index bf6b07f36f..c0218b3ace 100644 --- a/src/gui/painting/qtextureglyphcache_p.h +++ b/src/gui/painting/qtextureglyphcache_p.h @@ -75,10 +75,11 @@ public: }; bool populate(QFontEngine *fontEngine, - int numGlyphs, + qsizetype numGlyphs, const glyph_t *glyphs, const QFixedPoint *positions, - QPainter::RenderHints renderHints = QPainter::RenderHints()); + QPainter::RenderHints renderHints = QPainter::RenderHints(), + bool includeGlyphCacheScale = false); bool hasPendingGlyphs() const { return !m_pendingGlyphs.isEmpty(); } void fillInPendingGlyphs(); diff --git a/src/gui/painting/qtransform.cpp b/src/gui/painting/qtransform.cpp index 5fa5d04e54..df57d2c190 100644 --- a/src/gui/painting/qtransform.cpp +++ b/src/gui/painting/qtransform.cpp @@ -54,7 +54,7 @@ static void nanWarning(const char *func) if (t == TxProject) { \ qreal w = (m_matrix[0][2] * FX_ + m_matrix[1][2] * FY_ + m_matrix[2][2]); \ if (w < qreal(Q_NEAR_CLIP)) w = qreal(Q_NEAR_CLIP); \ - w = 1./w; \ + w = qreal(1.)/w; \ nx *= w; \ ny *= w; \ } \ @@ -358,7 +358,7 @@ QTransform &QTransform::translate(qreal dx, qreal dy) if (dx == 0 && dy == 0) return *this; #ifndef QT_NO_DEBUG - if (qIsNaN(dx) | qIsNaN(dy)) { + if (qIsNaN(dx) || qIsNaN(dy)) { nanWarning("translate"); return *this; } @@ -401,7 +401,7 @@ QTransform &QTransform::translate(qreal dx, qreal dy) QTransform QTransform::fromTranslate(qreal dx, qreal dy) { #ifndef QT_NO_DEBUG - if (qIsNaN(dx) | qIsNaN(dy)) { + if (qIsNaN(dx) || qIsNaN(dy)) { nanWarning("fromTranslate"); return QTransform(); } @@ -426,7 +426,7 @@ QTransform & QTransform::scale(qreal sx, qreal sy) if (sx == 1 && sy == 1) return *this; #ifndef QT_NO_DEBUG - if (qIsNaN(sx) | qIsNaN(sy)) { + if (qIsNaN(sx) || qIsNaN(sy)) { nanWarning("scale"); return *this; } @@ -467,7 +467,7 @@ QTransform & QTransform::scale(qreal sx, qreal sy) QTransform QTransform::fromScale(qreal sx, qreal sy) { #ifndef QT_NO_DEBUG - if (qIsNaN(sx) | qIsNaN(sy)) { + if (qIsNaN(sx) || qIsNaN(sy)) { nanWarning("fromScale"); return QTransform(); } @@ -492,7 +492,7 @@ QTransform & QTransform::shear(qreal sh, qreal sv) if (sh == 0 && sv == 0) return *this; #ifndef QT_NO_DEBUG - if (qIsNaN(sh) | qIsNaN(sv)) { + if (qIsNaN(sh) || qIsNaN(sv)) { nanWarning("shear"); return *this; } @@ -533,28 +533,33 @@ QTransform & QTransform::shear(qreal sh, qreal sv) return *this; } -const qreal inv_dist_to_plane = 1. / 1024.; - /*! - \fn QTransform &QTransform::rotate(qreal angle, Qt::Axis axis) + \since 6.5 - Rotates the coordinate system counterclockwise by the given \a angle - about the specified \a axis and returns a reference to the matrix. + Rotates the coordinate system counterclockwise by the given angle \a a + about the specified \a axis at distance \a distanceToPlane from the + screen and returns a reference to the matrix. +//! [transform-rotate-note] Note that if you apply a QTransform to a point defined in widget coordinates, the direction of the rotation will be clockwise because the y-axis points downwards. The angle is specified in degrees. +//! [transform-rotate-note] + + If \a distanceToPlane is zero, it will be ignored. This is suitable + for implementing orthographic projections where the z coordinate should + be dropped rather than projected. \sa setMatrix() */ -QTransform & QTransform::rotate(qreal a, Qt::Axis axis) +QTransform & QTransform::rotate(qreal a, Qt::Axis axis, qreal distanceToPlane) { if (a == 0) return *this; #ifndef QT_NO_DEBUG - if (qIsNaN(a)) { + if (qIsNaN(a) || qIsNaN(distanceToPlane)) { nanWarning("rotate"); return *this; } @@ -617,13 +622,16 @@ QTransform & QTransform::rotate(qreal a, Qt::Axis axis) if (m_dirty < TxRotate) m_dirty = TxRotate; } else { + if (!qIsNull(distanceToPlane)) + sina /= distanceToPlane; + QTransform result; if (axis == Qt::YAxis) { result.m_matrix[0][0] = cosa; - result.m_matrix[0][2] = -sina * inv_dist_to_plane; + result.m_matrix[0][2] = -sina; } else { result.m_matrix[1][1] = cosa; - result.m_matrix[1][2] = -sina * inv_dist_to_plane; + result.m_matrix[1][2] = -sina; } result.m_type = TxProject; *this = result * *this; @@ -632,24 +640,49 @@ QTransform & QTransform::rotate(qreal a, Qt::Axis axis) return *this; } +#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) +/*! + \overload + + Rotates the coordinate system counterclockwise by the given angle \a a + about the specified \a axis at distance 1024.0 from the screen and + returns a reference to the matrix. + + \include qtransform.cpp transform-rotate-note + + \sa setMatrix +*/ +QTransform &QTransform::rotate(qreal a, Qt::Axis axis) +{ + return rotate(a, axis, 1024.0); +} +#endif + /*! - \fn QTransform & QTransform::rotateRadians(qreal angle, Qt::Axis axis) + \since 6.5 - Rotates the coordinate system counterclockwise by the given \a angle - about the specified \a axis and returns a reference to the matrix. + Rotates the coordinate system counterclockwise by the given angle \a a + about the specified \a axis at distance \a distanceToPlane from the + screen and returns a reference to the matrix. +//! [transform-rotate-radians-note] Note that if you apply a QTransform to a point defined in widget coordinates, the direction of the rotation will be clockwise because the y-axis points downwards. The angle is specified in radians. +//! [transform-rotate-radians-note] + + If \a distanceToPlane is zero, it will be ignored. This is suitable + for implementing orthographic projections where the z coordinate should + be dropped rather than projected. \sa setMatrix() */ -QTransform & QTransform::rotateRadians(qreal a, Qt::Axis axis) +QTransform & QTransform::rotateRadians(qreal a, Qt::Axis axis, qreal distanceToPlane) { #ifndef QT_NO_DEBUG - if (qIsNaN(a)) { + if (qIsNaN(a) || qIsNaN(distanceToPlane)) { nanWarning("rotateRadians"); return *this; } @@ -700,13 +733,16 @@ QTransform & QTransform::rotateRadians(qreal a, Qt::Axis axis) if (m_dirty < TxRotate) m_dirty = TxRotate; } else { + if (!qIsNull(distanceToPlane)) + sina /= distanceToPlane; + QTransform result; if (axis == Qt::YAxis) { result.m_matrix[0][0] = cosa; - result.m_matrix[0][2] = -sina * inv_dist_to_plane; + result.m_matrix[0][2] = -sina; } else { result.m_matrix[1][1] = cosa; - result.m_matrix[1][2] = -sina * inv_dist_to_plane; + result.m_matrix[1][2] = -sina; } result.m_type = TxProject; *this = result * *this; @@ -714,6 +750,24 @@ QTransform & QTransform::rotateRadians(qreal a, Qt::Axis axis) return *this; } +#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) +/*! + \overload + + Rotates the coordinate system counterclockwise by the given angle \a a + about the specified \a axis at distance 1024.0 from the screen and + returns a reference to the matrix. + + \include qtransform.cpp transform-rotate-radians-note + + \sa setMatrix() +*/ +QTransform &QTransform::rotateRadians(qreal a, Qt::Axis axis) +{ + return rotateRadians(a, axis, 1024.0); +} +#endif + /*! \fn bool QTransform::operator==(const QTransform &matrix) const Returns \c true if this matrix is equal to the given \a matrix, @@ -1091,30 +1145,8 @@ QPoint QTransform::map(const QPoint &p) const qreal x = 0, y = 0; TransformationType t = inline_type(); - switch(t) { - case TxNone: - x = fx; - y = fy; - break; - case TxTranslate: - x = fx + m_matrix[2][0]; - y = fy + m_matrix[2][1]; - break; - case TxScale: - x = m_matrix[0][0] * fx + m_matrix[2][0]; - y = m_matrix[1][1] * fy + m_matrix[2][1]; - break; - case TxRotate: - case TxShear: - case TxProject: - x = m_matrix[0][0] * fx + m_matrix[1][0] * fy + m_matrix[2][0]; - y = m_matrix[0][1] * fx + m_matrix[1][1] * fy + m_matrix[2][1]; - if (t == TxProject) { - qreal w = 1./(m_matrix[0][2] * fx + m_matrix[1][2] * fy + m_matrix[2][2]); - x *= w; - y *= w; - } - } + MAP(fx, fy, x, y); + return QPoint(qRound(x), qRound(y)); } @@ -1142,30 +1174,8 @@ QPointF QTransform::map(const QPointF &p) const qreal x = 0, y = 0; TransformationType t = inline_type(); - switch(t) { - case TxNone: - x = fx; - y = fy; - break; - case TxTranslate: - x = fx + m_matrix[2][0]; - y = fy + m_matrix[2][1]; - break; - case TxScale: - x = m_matrix[0][0] * fx + m_matrix[2][0]; - y = m_matrix[1][1] * fy + m_matrix[2][1]; - break; - case TxRotate: - case TxShear: - case TxProject: - x = m_matrix[0][0] * fx + m_matrix[1][0] * fy + m_matrix[2][0]; - y = m_matrix[0][1] * fx + m_matrix[1][1] * fy + m_matrix[2][1]; - if (t == TxProject) { - qreal w = 1./(m_matrix[0][2] * fx + m_matrix[1][2] * fy + m_matrix[2][2]); - x *= w; - y *= w; - } - } + MAP(fx, fy, x, y); + return QPointF(x, y); } @@ -1213,41 +1223,9 @@ QLine QTransform::map(const QLine &l) const qreal x1 = 0, y1 = 0, x2 = 0, y2 = 0; TransformationType t = inline_type(); - switch(t) { - case TxNone: - x1 = fx1; - y1 = fy1; - x2 = fx2; - y2 = fy2; - break; - case TxTranslate: - x1 = fx1 + m_matrix[2][0]; - y1 = fy1 + m_matrix[2][1]; - x2 = fx2 + m_matrix[2][0]; - y2 = fy2 + m_matrix[2][1]; - break; - case TxScale: - x1 = m_matrix[0][0] * fx1 + m_matrix[2][0]; - y1 = m_matrix[1][1] * fy1 + m_matrix[2][1]; - x2 = m_matrix[0][0] * fx2 + m_matrix[2][0]; - y2 = m_matrix[1][1] * fy2 + m_matrix[2][1]; - break; - case TxRotate: - case TxShear: - case TxProject: - x1 = m_matrix[0][0] * fx1 + m_matrix[1][0] * fy1 + m_matrix[2][0]; - y1 = m_matrix[0][1] * fx1 + m_matrix[1][1] * fy1 + m_matrix[2][1]; - x2 = m_matrix[0][0] * fx2 + m_matrix[1][0] * fy2 + m_matrix[2][0]; - y2 = m_matrix[0][1] * fx2 + m_matrix[1][1] * fy2 + m_matrix[2][1]; - if (t == TxProject) { - qreal w = 1./(m_matrix[0][2] * fx1 + m_matrix[1][2] * fy1 + m_matrix[2][2]); - x1 *= w; - y1 *= w; - w = 1./(m_matrix[0][2] * fx2 + m_matrix[1][2] * fy2 + m_matrix[2][2]); - x2 *= w; - y2 *= w; - } - } + MAP(fx1, fy1, x1, y1); + MAP(fx2, fy2, x2, y2); + return QLine(qRound(x1), qRound(y1), qRound(x2), qRound(y2)); } @@ -1272,66 +1250,12 @@ QLineF QTransform::map(const QLineF &l) const qreal x1 = 0, y1 = 0, x2 = 0, y2 = 0; TransformationType t = inline_type(); - switch(t) { - case TxNone: - x1 = fx1; - y1 = fy1; - x2 = fx2; - y2 = fy2; - break; - case TxTranslate: - x1 = fx1 + m_matrix[2][0]; - y1 = fy1 + m_matrix[2][1]; - x2 = fx2 + m_matrix[2][0]; - y2 = fy2 + m_matrix[2][1]; - break; - case TxScale: - x1 = m_matrix[0][0] * fx1 + m_matrix[2][0]; - y1 = m_matrix[1][1] * fy1 + m_matrix[2][1]; - x2 = m_matrix[0][0] * fx2 + m_matrix[2][0]; - y2 = m_matrix[1][1] * fy2 + m_matrix[2][1]; - break; - case TxRotate: - case TxShear: - case TxProject: - x1 = m_matrix[0][0] * fx1 + m_matrix[1][0] * fy1 + m_matrix[2][0]; - y1 = m_matrix[0][1] * fx1 + m_matrix[1][1] * fy1 + m_matrix[2][1]; - x2 = m_matrix[0][0] * fx2 + m_matrix[1][0] * fy2 + m_matrix[2][0]; - y2 = m_matrix[0][1] * fx2 + m_matrix[1][1] * fy2 + m_matrix[2][1]; - if (t == TxProject) { - qreal w = 1./(m_matrix[0][2] * fx1 + m_matrix[1][2] * fy1 + m_matrix[2][2]); - x1 *= w; - y1 *= w; - w = 1./(m_matrix[0][2] * fx2 + m_matrix[1][2] * fy2 + m_matrix[2][2]); - x2 *= w; - y2 *= w; - } - } - return QLineF(x1, y1, x2, y2); -} + MAP(fx1, fy1, x1, y1); + MAP(fx2, fy2, x2, y2); -static QPolygonF mapProjective(const QTransform &transform, const QPolygonF &poly) -{ - if (poly.size() == 0) - return poly; - - if (poly.size() == 1) - return QPolygonF() << transform.map(poly.at(0)); - - QPainterPath path; - path.addPolygon(poly); - - path = transform.map(path); - - QPolygonF result; - const int elementCount = path.elementCount(); - result.reserve(elementCount); - for (int i = 0; i < elementCount; ++i) - result << path.elementAt(i); - return result; + return QLineF(x1, y1, x2, y2); } - /*! \fn QPolygonF operator *(const QPolygonF &polygon, const QTransform &matrix) \since 4.3 @@ -1365,9 +1289,6 @@ QPolygonF QTransform::map(const QPolygonF &a) const if (t <= TxTranslate) return a.translated(m_matrix[2][0], m_matrix[2][1]); - if (t >= QTransform::TxProject) - return mapProjective(*this, a); - int size = a.size(); int i; QPolygonF p(size); @@ -1395,9 +1316,6 @@ QPolygon QTransform::map(const QPolygon &a) const if (t <= TxTranslate) return a.translated(qRound(m_matrix[2][0]), qRound(m_matrix[2][1])); - if (t >= QTransform::TxProject) - return mapProjective(*this, QPolygonF(a)).toPolygon(); - int size = a.size(); int i; QPolygon p(size); @@ -1459,7 +1377,7 @@ QRegion QTransform::map(const QRegion &r) const if (!nr.isEmpty()) rects.append(nr); } - res.setRects(rects.constData(), rects.count()); + res.setRects(rects.constData(), rects.size()); } return res; } @@ -1706,7 +1624,7 @@ QPolygon QTransform::mapToPolygon(const QRect &rect) const */ bool QTransform::squareToQuad(const QPolygonF &quad, QTransform &trans) { - if (quad.count() != 4) + if (quad.size() != 4) return false; qreal dx0 = quad[0].x(); @@ -1828,14 +1746,6 @@ void QTransform::setMatrix(qreal m11, qreal m12, qreal m13, m_dirty = TxProject; } -static inline bool needsPerspectiveClipping(const QRectF &rect, const QTransform &transform) -{ - const qreal wx = qMin(transform.m13() * rect.left(), transform.m13() * rect.right()); - const qreal wy = qMin(transform.m23() * rect.top(), transform.m23() * rect.bottom()); - - return wx + wy + transform.m33() < Q_NEAR_CLIP; -} - QRect QTransform::mapRect(const QRect &rect) const { TransformationType t = inline_type(); @@ -1856,8 +1766,7 @@ QRect QTransform::mapRect(const QRect &rect) const y -= h; } return QRect(x, y, w, h); - } else if (t < TxProject || !needsPerspectiveClipping(rect, *this)) { - // see mapToPolygon for explanations of the algorithm. + } else { qreal x = 0, y = 0; MAP(rect.left(), rect.top(), x, y); qreal xmin = x; @@ -1879,11 +1788,7 @@ QRect QTransform::mapRect(const QRect &rect) const ymin = qMin(ymin, y); xmax = qMax(xmax, x); ymax = qMax(ymax, y); - return QRect(qRound(xmin), qRound(ymin), qRound(xmax)-qRound(xmin), qRound(ymax)-qRound(ymin)); - } else { - QPainterPath path; - path.addRect(rect); - return map(path).boundingRect().toRect(); + return QRectF(xmin, ymin, xmax-xmin, ymax-ymin).toRect(); } } @@ -1926,7 +1831,7 @@ QRectF QTransform::mapRect(const QRectF &rect) const y -= h; } return QRectF(x, y, w, h); - } else if (t < TxProject || !needsPerspectiveClipping(rect, *this)) { + } else { qreal x = 0, y = 0; MAP(rect.x(), rect.y(), x, y); qreal xmin = x; @@ -1949,10 +1854,6 @@ QRectF QTransform::mapRect(const QRectF &rect) const xmax = qMax(xmax, x); ymax = qMax(ymax, y); return QRectF(xmin, ymin, xmax-xmin, ymax - ymin); - } else { - QPainterPath path; - path.addRect(rect); - return map(path).boundingRect(); } } diff --git a/src/gui/painting/qtransform.h b/src/gui/painting/qtransform.h index 71418935d1..e5b245d8c9 100644 --- a/src/gui/painting/qtransform.h +++ b/src/gui/painting/qtransform.h @@ -84,8 +84,17 @@ public: QTransform &translate(qreal dx, qreal dy); QTransform &scale(qreal sx, qreal sy); QTransform &shear(qreal sh, qreal sv); +#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) + QTransform &rotate(qreal a, Qt::Axis axis, qreal distanceToPlane); + // ### Qt7: Remove QTransform &rotate(qreal a, Qt::Axis axis = Qt::ZAxis); + QTransform &rotateRadians(qreal a, Qt::Axis axis, qreal distanceToPlane); + // ### Qt7: Remove QTransform &rotateRadians(qreal a, Qt::Axis axis = Qt::ZAxis); +#else + QTransform &rotate(qreal a, Qt::Axis axis = Qt::ZAxis, qreal distanceToPlane = 1024.0f); + QTransform &rotateRadians(qreal a, Qt::Axis axis = Qt::ZAxis, qreal distanceToPlane = 1024.0f); +#endif static bool squareToQuad(const QPolygonF &square, QTransform &result); static bool quadToSquare(const QPolygonF &quad, QTransform &result); diff --git a/src/gui/painting/qtriangulator.cpp b/src/gui/painting/qtriangulator.cpp index 86f3a2b20c..029566f1b9 100644 --- a/src/gui/painting/qtriangulator.cpp +++ b/src/gui/painting/qtriangulator.cpp @@ -2321,3 +2321,5 @@ QPolylineSet qPolyline(const QPainterPath &path, } QT_END_NAMESPACE + +#undef Q_FIXED_POINT_SCALE diff --git a/src/gui/painting/shaders/backingstorecompose.frag b/src/gui/painting/shaders/backingstorecompose.frag index e0c419840e..3b08ade035 100644 --- a/src/gui/painting/shaders/backingstorecompose.frag +++ b/src/gui/painting/shaders/backingstorecompose.frag @@ -7,7 +7,7 @@ layout(std140, binding = 0) uniform buf { mat4 vertexTransform; mat3 textureTransform; float opacity; - int swapRedBlue; + int textureSwizzle; }; layout(binding = 1) uniform sampler2D textureSampler; @@ -16,8 +16,10 @@ void main() { vec4 tmpFragColor = texture(textureSampler, v_texcoord); tmpFragColor.a *= opacity; - if (swapRedBlue == 0) + if (textureSwizzle == 0) fragColor = tmpFragColor; + else if(textureSwizzle == 2) + fragColor.argb = tmpFragColor; else - fragColor = tmpFragColor.bgra; + fragColor.bgra = tmpFragColor; } diff --git a/src/gui/painting/shaders/backingstorecompose.frag.qsb b/src/gui/painting/shaders/backingstorecompose.frag.qsb Binary files differindex a7c2dfebce..63ba55eed8 100644 --- a/src/gui/painting/shaders/backingstorecompose.frag.qsb +++ b/src/gui/painting/shaders/backingstorecompose.frag.qsb diff --git a/src/gui/painting/shaders/backingstorecompose.vert b/src/gui/painting/shaders/backingstorecompose.vert index bb8444ade5..0c72c97419 100644 --- a/src/gui/painting/shaders/backingstorecompose.vert +++ b/src/gui/painting/shaders/backingstorecompose.vert @@ -9,7 +9,7 @@ layout(std140, binding = 0) uniform buf { mat4 vertexTransform; mat3 textureTransform; float opacity; - int swapRedBlue; + int textureSwizzle; }; void main() diff --git a/src/gui/painting/shaders/backingstorecompose.vert.qsb b/src/gui/painting/shaders/backingstorecompose.vert.qsb Binary files differindex 1f464516fe..1aa6e661f8 100644 --- a/src/gui/painting/shaders/backingstorecompose.vert.qsb +++ b/src/gui/painting/shaders/backingstorecompose.vert.qsb diff --git a/src/gui/painting/webgradients.cpp b/src/gui/painting/webgradients.cpp index 5924fe6e60..fd5031349e 100644 --- a/src/gui/painting/webgradients.cpp +++ b/src/gui/painting/webgradients.cpp @@ -346,8 +346,7 @@ static QList<QGradientStop> qt_preset_gradient_stops(QGradient::Preset preset) case QGradient::NumPresets: Q_UNREACHABLE(); } - Q_UNREACHABLE(); - return {}; + Q_UNREACHABLE_RETURN({}); } static constexpr QGradient::QGradientData qt_preset_gradient_data[] = { |