Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
koffice/chalk/colorspaces/rgb_u8/kis_rgb_colorspace.cc

1502 lignes
50 KiB

/*
* Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
* Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include <config.h>
#include <limits.h>
#include <stdlib.h>
#include LCMS_HEADER
#include <tqimage.h>
#include <tqcolor.h>
#include <kdebug.h>
#include <tdelocale.h>
#include "kis_rgb_colorspace.h"
#include "kis_u8_base_colorspace.h"
#include "kis_color_conversions.h"
#include "kis_integer_maths.h"
#include "kis_colorspace_factory_registry.h"
#include "composite.h"
#define downscale(quantum) (quantum) //((unsigned char) ((quantum)/257UL))
#define upscale(value) (value) // ((TQ_UINT8) (257UL*(value)))
namespace {
const TQ_INT32 MAX_CHANNEL_RGB = 3;
const TQ_INT32 MAX_CHANNEL_RGBA = 4;
}
KisRgbColorSpace::KisRgbColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) :
KisU8BaseColorSpace(KisID("RGBA", i18n("RGB (8-bit integer/channel)")), TYPE_BGRA_8, icSigRgbData, parent, p)
{
m_channels.push_back(new KisChannelInfo(i18n("Red"), i18n("R"), 2, KisChannelInfo::COLOR, KisChannelInfo::UINT8, 1, TQColor(255,0,0)));
m_channels.push_back(new KisChannelInfo(i18n("Green"), i18n("G"), 1, KisChannelInfo::COLOR, KisChannelInfo::UINT8, 1, TQColor(0,255,0)));
m_channels.push_back(new KisChannelInfo(i18n("Blue"), i18n("B"), 0, KisChannelInfo::COLOR, KisChannelInfo::UINT8, 1, TQColor(0,0,255)));
m_channels.push_back(new KisChannelInfo(i18n("Alpha"), i18n("A"), 3, KisChannelInfo::ALPHA, KisChannelInfo::UINT8));
m_alphaPos = PIXEL_ALPHA;
init();
}
KisRgbColorSpace::~KisRgbColorSpace()
{
}
void KisRgbColorSpace::setPixel(TQ_UINT8 *pixel, TQ_UINT8 red, TQ_UINT8 green, TQ_UINT8 blue, TQ_UINT8 alpha) const
{
pixel[PIXEL_RED] = red;
pixel[PIXEL_GREEN] = green;
pixel[PIXEL_BLUE] = blue;
pixel[PIXEL_ALPHA] = alpha;
}
void KisRgbColorSpace::getPixel(const TQ_UINT8 *pixel, TQ_UINT8 *red, TQ_UINT8 *green, TQ_UINT8 *blue, TQ_UINT8 *alpha) const
{
*red = pixel[PIXEL_RED];
*green = pixel[PIXEL_GREEN];
*blue = pixel[PIXEL_BLUE];
*alpha = pixel[PIXEL_ALPHA];
}
void KisRgbColorSpace::mixColors(const TQ_UINT8 **colors, const TQ_UINT8 *weights, TQ_UINT32 nColors, TQ_UINT8 *dst) const
{
TQ_UINT32 totalRed = 0, totalGreen = 0, totalBlue = 0, totalAlpha = 0;
while (nColors--)
{
TQ_UINT32 alpha = (*colors)[PIXEL_ALPHA];
// although we only mult by weight and not by weight*256/255
// we divide by the same amount later, so there is no need
TQ_UINT32 alphaTimesWeight = alpha * *weights;
totalRed += (*colors)[PIXEL_RED] * alphaTimesWeight;
totalGreen += (*colors)[PIXEL_GREEN] * alphaTimesWeight;
totalBlue += (*colors)[PIXEL_BLUE] * alphaTimesWeight;
totalAlpha += alphaTimesWeight;
weights++;
colors++;
}
// note this is correct - if you look at the above calculation
if (totalAlpha > 255*255) totalAlpha = 255*255;
// Divide by 255.
dst[PIXEL_ALPHA] =(((totalAlpha + 0x80)>>8)+totalAlpha + 0x80) >>8;
if (totalAlpha > 0) {
totalRed = totalRed / totalAlpha;
totalGreen = totalGreen / totalAlpha;
totalBlue = totalBlue / totalAlpha;
} // else the values are already 0 too
TQ_UINT32 dstRed = totalRed;
//Q_ASSERT(dstRed <= 255);
if (dstRed > 255) dstRed = 255;
dst[PIXEL_RED] = dstRed;
TQ_UINT32 dstGreen = totalGreen;
//Q_ASSERT(dstGreen <= 255);
if (dstGreen > 255) dstGreen = 255;
dst[PIXEL_GREEN] = dstGreen;
TQ_UINT32 dstBlue = totalBlue;
//Q_ASSERT(dstBlue <= 255);
if (dstBlue > 255) dstBlue = 255;
dst[PIXEL_BLUE] = dstBlue;
}
void KisRgbColorSpace::convolveColors(TQ_UINT8** colors, TQ_INT32* kernelValues, KisChannelInfo::enumChannelFlags channelFlags, TQ_UINT8 *dst, TQ_INT32 factor, TQ_INT32 offset, TQ_INT32 nColors) const
{
TQ_INT64 totalRed = 0, totalGreen = 0, totalBlue = 0, totalAlpha = 0;
TQ_INT32 totalWeight = 0, totalWeightTransparent = 0;
while (nColors--)
{
TQ_INT32 weight = *kernelValues;
if (weight != 0) {
if((*colors)[PIXEL_ALPHA] == 0)
{
totalWeightTransparent += weight;
} else {
totalRed += (*colors)[PIXEL_RED] * weight;
totalGreen += (*colors)[PIXEL_GREEN] * weight;
totalBlue += (*colors)[PIXEL_BLUE] * weight;
}
totalAlpha += (*colors)[PIXEL_ALPHA] * weight;
totalWeight += weight;
}
colors++;
kernelValues++;
}
if(totalWeightTransparent == 0)
{
if (channelFlags & KisChannelInfo::FLAG_COLOR) {
dst[PIXEL_RED] = CLAMP((totalRed / factor) + offset, 0, TQ_UINT8_MAX);
dst[PIXEL_GREEN] = CLAMP((totalGreen / factor) + offset, 0, TQ_UINT8_MAX);
dst[PIXEL_BLUE] = CLAMP((totalBlue / factor) + offset, 0, TQ_UINT8_MAX);
}
if (channelFlags & KisChannelInfo::FLAG_ALPHA) {
dst[PIXEL_ALPHA] = CLAMP((totalAlpha/ factor) + offset, 0, TQ_UINT8_MAX);
}
} else if(totalWeightTransparent != totalWeight && (channelFlags & KisChannelInfo::FLAG_COLOR)) {
if(totalWeight == factor)
{
TQ_INT64 a = ( totalWeight - totalWeightTransparent );
dst[PIXEL_RED] = CLAMP((totalRed / a) + offset, 0, TQ_UINT8_MAX);
dst[PIXEL_GREEN] = CLAMP((totalGreen / a) + offset, 0, TQ_UINT8_MAX);
dst[PIXEL_BLUE] = CLAMP((totalBlue / a) + offset, 0, TQ_UINT8_MAX);
} else {
double a = totalWeight / ( factor * ( totalWeight - totalWeightTransparent ) ); // use double as it can saturate
dst[PIXEL_RED] = CLAMP( (TQ_UINT8)(totalRed * a) + offset, 0, TQ_UINT8_MAX);
dst[PIXEL_GREEN] = CLAMP( (TQ_UINT8)(totalGreen * a) + offset, 0, TQ_UINT8_MAX);
dst[PIXEL_BLUE] = CLAMP( (TQ_UINT8)(totalBlue * a) + offset, 0, TQ_UINT8_MAX);
}
}
if (channelFlags & KisChannelInfo::FLAG_ALPHA) {
dst[PIXEL_ALPHA] = CLAMP((totalAlpha/ factor) + offset, 0, TQ_UINT8_MAX);
}
}
void KisRgbColorSpace::invertColor(TQ_UINT8 * src, TQ_INT32 nPixels)
{
TQ_UINT32 psize = pixelSize();
while (nPixels--)
{
src[PIXEL_RED] = TQ_UINT8_MAX - src[PIXEL_RED];
src[PIXEL_GREEN] = TQ_UINT8_MAX - src[PIXEL_GREEN];
src[PIXEL_BLUE] = TQ_UINT8_MAX - src[PIXEL_BLUE];
src += psize;
}
}
void KisRgbColorSpace::darken(const TQ_UINT8 * src, TQ_UINT8 * dst, TQ_INT32 shade, bool compensate, double compensation, TQ_INT32 nPixels) const
{
TQ_UINT32 pSize = pixelSize();
while (nPixels--) {
if (compensate) {
dst[PIXEL_RED] = (TQ_INT8) TQMIN(255,((src[PIXEL_RED] * shade) / (compensation * 255)));
dst[PIXEL_GREEN] = (TQ_INT8) TQMIN(255,((src[PIXEL_GREEN] * shade) / (compensation * 255)));
dst[PIXEL_BLUE] = (TQ_INT8) TQMIN(255,((src[PIXEL_BLUE] * shade) / (compensation * 255)));
}
else {
dst[PIXEL_RED] = (TQ_INT8) TQMIN(255, (src[PIXEL_RED] * shade / 255));
dst[PIXEL_BLUE] = (TQ_INT8) TQMIN(255, (src[PIXEL_BLUE] * shade / 255));
dst[PIXEL_GREEN] = (TQ_INT8) TQMIN(255, (src[PIXEL_GREEN] * shade / 255));
}
dst += pSize;
src += pSize;
}
}
TQ_UINT8 KisRgbColorSpace::intensity8(const TQ_UINT8 * src) const
{
return (TQ_UINT8)((src[PIXEL_RED] * 0.30 + src[PIXEL_GREEN] * 0.59 + src[PIXEL_BLUE] * 0.11) + 0.5);
}
TQValueVector<KisChannelInfo *> KisRgbColorSpace::channels() const
{
return m_channels;
}
TQ_UINT32 KisRgbColorSpace::nChannels() const
{
return MAX_CHANNEL_RGBA;
}
TQ_UINT32 KisRgbColorSpace::nColorChannels() const
{
return MAX_CHANNEL_RGB;
}
TQ_UINT32 KisRgbColorSpace::pixelSize() const
{
return MAX_CHANNEL_RGBA;
}
TQImage KisRgbColorSpace::convertToTQImage(const TQ_UINT8 *data, TQ_INT32 width, TQ_INT32 height,
KisProfile * dstProfile,
TQ_INT32 renderingIntent, float /*exposure*/)
{
Q_ASSERT(data);
TQImage img = TQImage(const_cast<TQ_UINT8 *>(data), width, height, 32, 0, 0, TQImage::LittleEndian);
img.setAlphaBuffer(true);
// XXX: The previous version of this code used the quantum data directly
// as an optimisation. We're introducing a copy overhead here which could
// be factored out again if needed.
img = img.copy();
if (dstProfile != 0) {
KisColorSpace *dstCS = m_parent->getColorSpace(KisID("RGBA",""), dstProfile->productName());
convertPixelsTo(img.bits(),
img.bits(), dstCS,
width * height, renderingIntent);
}
return img;
}
void KisRgbColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride,
const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride,
const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride,
TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
{
while (rows > 0) {
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
// apply the alphamask
if(mask != 0)
{
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
if (opacity != OPACITY_OPAQUE) {
srcAlpha = UINT8_MULT(srcAlpha, opacity);
}
if (srcAlpha == OPACITY_OPAQUE) {
memcpy(dst, src, MAX_CHANNEL_RGBA * sizeof(TQ_UINT8));
} else {
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
TQ_UINT8 srcBlend;
if (dstAlpha == OPACITY_OPAQUE) {
srcBlend = srcAlpha;
} else {
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
dst[PIXEL_ALPHA] = newAlpha;
if (newAlpha != 0) {
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
} else {
srcBlend = srcAlpha;
}
}
if (srcBlend == OPACITY_OPAQUE) {
memcpy(dst, src, MAX_CHANNEL_RGB * sizeof(TQ_UINT8));
} else {
dst[PIXEL_RED] = UINT8_BLEND(src[PIXEL_RED], dst[PIXEL_RED], srcBlend);
dst[PIXEL_GREEN] = UINT8_BLEND(src[PIXEL_GREEN], dst[PIXEL_GREEN], srcBlend);
dst[PIXEL_BLUE] = UINT8_BLEND(src[PIXEL_BLUE], dst[PIXEL_BLUE], srcBlend);
}
}
}
columns--;
src += MAX_CHANNEL_RGBA;
dst += MAX_CHANNEL_RGBA;
}
rows--;
srcRowStart += srcRowStride;
dstRowStart += dstRowStride;
if(maskRowStart)
maskRowStart += maskRowStride;
}
}
void KisRgbColorSpace::compositeAlphaDarken(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride,
const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride,
const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride,
TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
{
while (rows > 0) {
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
// apply the alphamask
if(mask != 0)
{
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (opacity != OPACITY_OPAQUE) {
srcAlpha = UINT8_MULT(srcAlpha, opacity);
}
if (srcAlpha != OPACITY_TRANSPARENT && srcAlpha >= dstAlpha) {
dst[PIXEL_ALPHA] = srcAlpha;
memcpy(dst, src, MAX_CHANNEL_RGB * sizeof(TQ_UINT8));
}
columns--;
src += MAX_CHANNEL_RGBA;
dst += MAX_CHANNEL_RGBA;
}
rows--;
srcRowStart += srcRowStride;
dstRowStart += dstRowStride;
if(maskRowStart)
maskRowStart += maskRowStride;
}
}
void KisRgbColorSpace::compositeMultiply(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
{
while (rows > 0) {
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphamask
if(mask != 0)
{
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
if (opacity != OPACITY_OPAQUE) {
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
}
TQ_UINT8 srcBlend;
if (dstAlpha == OPACITY_OPAQUE) {
srcBlend = srcAlpha;
} else {
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
dst[PIXEL_ALPHA] = newAlpha;
if (newAlpha != 0) {
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
} else {
srcBlend = srcAlpha;
}
}
TQ_UINT8 srcColor = src[PIXEL_RED];
TQ_UINT8 dstColor = dst[PIXEL_RED];
srcColor = UINT8_MULT(srcColor, dstColor);
dst[PIXEL_RED] = UINT8_BLEND(srcColor, dstColor, srcBlend);
srcColor = src[PIXEL_GREEN];
dstColor = dst[PIXEL_GREEN];
srcColor = UINT8_MULT(srcColor, dstColor);
dst[PIXEL_GREEN] = UINT8_BLEND(srcColor, dstColor, srcBlend);
srcColor = src[PIXEL_BLUE];
dstColor = dst[PIXEL_BLUE];
srcColor = UINT8_MULT(srcColor, dstColor);
dst[PIXEL_BLUE] = UINT8_BLEND(srcColor, dstColor, srcBlend);
}
columns--;
src += MAX_CHANNEL_RGBA;
dst += MAX_CHANNEL_RGBA;
}
rows--;
srcRowStart += srcRowStride;
dstRowStart += dstRowStride;
if(maskRowStart)
maskRowStart += maskRowStride;
}
}
void KisRgbColorSpace::compositeDivide(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
{
while (rows > 0) {
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphamask
if(mask != 0)
{
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
if (opacity != OPACITY_OPAQUE) {
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
}
TQ_UINT8 srcBlend;
if (dstAlpha == OPACITY_OPAQUE) {
srcBlend = srcAlpha;
} else {
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
dst[PIXEL_ALPHA] = newAlpha;
if (newAlpha != 0) {
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
} else {
srcBlend = srcAlpha;
}
}
for (int channel = 0; channel < MAX_CHANNEL_RGB; channel++) {
TQ_UINT8 srcColor = src[channel];
TQ_UINT8 dstColor = dst[channel];
srcColor = TQMIN((dstColor * (UINT8_MAX + 1u) + (srcColor / 2u)) / (1u + srcColor), UINT8_MAX);
TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
dst[channel] = newColor;
}
}
columns--;
src += MAX_CHANNEL_RGBA;
dst += MAX_CHANNEL_RGBA;
}
rows--;
srcRowStart += srcRowStride;
dstRowStart += dstRowStride;
if(maskRowStart)
maskRowStart += maskRowStride;
}
}
void KisRgbColorSpace::compositeScreen(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
{
while (rows > 0) {
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphamask
if(mask != 0)
{
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
if (opacity != OPACITY_OPAQUE) {
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
}
TQ_UINT8 srcBlend;
if (dstAlpha == OPACITY_OPAQUE) {
srcBlend = srcAlpha;
} else {
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
dst[PIXEL_ALPHA] = newAlpha;
if (newAlpha != 0) {
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
} else {
srcBlend = srcAlpha;
}
}
for (int channel = 0; channel < MAX_CHANNEL_RGB; channel++) {
TQ_UINT8 srcColor = src[channel];
TQ_UINT8 dstColor = dst[channel];
srcColor = UINT8_MAX - UINT8_MULT(UINT8_MAX - dstColor, UINT8_MAX - srcColor);
TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
dst[channel] = newColor;
}
}
columns--;
src += MAX_CHANNEL_RGBA;
dst += MAX_CHANNEL_RGBA;
}
rows--;
srcRowStart += srcRowStride;
dstRowStart += dstRowStride;
if(maskRowStart)
maskRowStart += maskRowStride;
}
}
void KisRgbColorSpace::compositeOverlay(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
{
while (rows > 0) {
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphamask
if(mask != 0)
{
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
if (opacity != OPACITY_OPAQUE) {
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
}
TQ_UINT8 srcBlend;
if (dstAlpha == OPACITY_OPAQUE) {
srcBlend = srcAlpha;
} else {
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
dst[PIXEL_ALPHA] = newAlpha;
if (newAlpha != 0) {
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
} else {
srcBlend = srcAlpha;
}
}
for (int channel = 0; channel < MAX_CHANNEL_RGB; channel++) {
TQ_UINT8 srcColor = src[channel];
TQ_UINT8 dstColor = dst[channel];
srcColor = UINT8_MULT(dstColor, dstColor + UINT8_MULT(2 * srcColor, UINT8_MAX - dstColor));
TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
dst[channel] = newColor;
}
}
columns--;
src += MAX_CHANNEL_RGBA;
dst += MAX_CHANNEL_RGBA;
}
rows--;
srcRowStart += srcRowStride;
dstRowStart += dstRowStride;
if(maskRowStart)
maskRowStart += maskRowStride;
}
}
void KisRgbColorSpace::compositeDodge(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
{
while (rows > 0) {
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphamask
if(mask != 0)
{
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
if (opacity != OPACITY_OPAQUE) {
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
}
TQ_UINT8 srcBlend;
if (dstAlpha == OPACITY_OPAQUE) {
srcBlend = srcAlpha;
} else {
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
dst[PIXEL_ALPHA] = newAlpha;
if (newAlpha != 0) {
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
} else {
srcBlend = srcAlpha;
}
}
for (int channel = 0; channel < MAX_CHANNEL_RGB; channel++) {
TQ_UINT8 srcColor = src[channel];
TQ_UINT8 dstColor = dst[channel];
srcColor = TQMIN((dstColor * (UINT8_MAX + 1)) / (UINT8_MAX + 1 - srcColor), UINT8_MAX);
TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
dst[channel] = newColor;
}
}
columns--;
src += MAX_CHANNEL_RGBA;
dst += MAX_CHANNEL_RGBA;
}
rows--;
srcRowStart += srcRowStride;
dstRowStart += dstRowStride;
if(maskRowStart)
maskRowStart += maskRowStride;
}
}
void KisRgbColorSpace::compositeBurn(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
{
while (rows > 0) {
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphamask
if(mask != 0)
{
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
if (opacity != OPACITY_OPAQUE) {
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
}
TQ_UINT8 srcBlend;
if (dstAlpha == OPACITY_OPAQUE) {
srcBlend = srcAlpha;
} else {
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
dst[PIXEL_ALPHA] = newAlpha;
if (newAlpha != 0) {
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
} else {
srcBlend = srcAlpha;
}
}
for (int channel = 0; channel < MAX_CHANNEL_RGB; channel++) {
TQ_UINT8 srcColor = src[channel];
TQ_UINT8 dstColor = dst[channel];
srcColor = TQMIN(((UINT8_MAX - dstColor) * (UINT8_MAX + 1)) / (srcColor + 1), UINT8_MAX);
if (UINT8_MAX - srcColor > UINT8_MAX) srcColor = UINT8_MAX;
TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
dst[channel] = newColor;
}
}
columns--;
src += MAX_CHANNEL_RGBA;
dst += MAX_CHANNEL_RGBA;
}
rows--;
srcRowStart += srcRowStride;
dstRowStart += dstRowStride;
if(maskRowStart)
maskRowStart += maskRowStride;
}
}
void KisRgbColorSpace::compositeDarken(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
{
while (rows > 0) {
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphamask
if(mask != 0)
{
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
if (opacity != OPACITY_OPAQUE) {
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
}
TQ_UINT8 srcBlend;
if (dstAlpha == OPACITY_OPAQUE) {
srcBlend = srcAlpha;
} else {
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
dst[PIXEL_ALPHA] = newAlpha;
if (newAlpha != 0) {
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
} else {
srcBlend = srcAlpha;
}
}
for (int channel = 0; channel < MAX_CHANNEL_RGB; channel++) {
TQ_UINT8 srcColor = src[channel];
TQ_UINT8 dstColor = dst[channel];
srcColor = TQMIN(srcColor, dstColor);
TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
dst[channel] = newColor;
}
}
columns--;
src += MAX_CHANNEL_RGBA;
dst += MAX_CHANNEL_RGBA;
}
rows--;
srcRowStart += srcRowStride;
dstRowStart += dstRowStride;
if(maskRowStart)
maskRowStart += maskRowStride;
}
}
void KisRgbColorSpace::compositeLighten(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
{
while (rows > 0) {
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphamask
if(mask != 0)
{
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
if (opacity != OPACITY_OPAQUE) {
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
}
TQ_UINT8 srcBlend;
if (dstAlpha == OPACITY_OPAQUE) {
srcBlend = srcAlpha;
} else {
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
dst[PIXEL_ALPHA] = newAlpha;
if (newAlpha != 0) {
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
} else {
srcBlend = srcAlpha;
}
}
for (int channel = 0; channel < MAX_CHANNEL_RGB; channel++) {
TQ_UINT8 srcColor = src[channel];
TQ_UINT8 dstColor = dst[channel];
srcColor = TQMAX(srcColor, dstColor);
TQ_UINT8 newColor = UINT8_BLEND(srcColor, dstColor, srcBlend);
dst[channel] = newColor;
}
}
columns--;
src += MAX_CHANNEL_RGBA;
dst += MAX_CHANNEL_RGBA;
}
rows--;
srcRowStart += srcRowStride;
dstRowStart += dstRowStride;
if(maskRowStart)
maskRowStart += maskRowStride;
}
}
void KisRgbColorSpace::compositeHue(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
{
while (rows > 0) {
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphamask
if(mask != 0)
{
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
if (opacity != OPACITY_OPAQUE) {
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
}
TQ_UINT8 srcBlend;
if (dstAlpha == OPACITY_OPAQUE) {
srcBlend = srcAlpha;
} else {
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
dst[PIXEL_ALPHA] = newAlpha;
if (newAlpha != 0) {
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
} else {
srcBlend = srcAlpha;
}
}
int dstRed = dst[PIXEL_RED];
int dstGreen = dst[PIXEL_GREEN];
int dstBlue = dst[PIXEL_BLUE];
int srcHue;
int srcSaturation;
int srcValue;
int dstHue;
int dstSaturation;
int dstValue;
rgb_to_hsv(src[PIXEL_RED], src[PIXEL_GREEN], src[PIXEL_BLUE], &srcHue, &srcSaturation, &srcValue);
rgb_to_hsv(dstRed, dstGreen, dstBlue, &dstHue, &dstSaturation, &dstValue);
int srcRed;
int srcGreen;
int srcBlue;
hsv_to_rgb(srcHue, dstSaturation, dstValue, &srcRed, &srcGreen, &srcBlue);
dst[PIXEL_RED] = UINT8_BLEND(srcRed, dstRed, srcBlend);
dst[PIXEL_GREEN] = UINT8_BLEND(srcGreen, dstGreen, srcBlend);
dst[PIXEL_BLUE] = UINT8_BLEND(srcBlue, dstBlue, srcBlend);
}
columns--;
src += MAX_CHANNEL_RGBA;
dst += MAX_CHANNEL_RGBA;
}
rows--;
srcRowStart += srcRowStride;
dstRowStart += dstRowStride;
if(maskRowStart)
maskRowStart += maskRowStride;
}
}
void KisRgbColorSpace::compositeSaturation(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
{
while (rows > 0) {
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphamask
if(mask != 0)
{
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
if (opacity != OPACITY_OPAQUE) {
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
}
TQ_UINT8 srcBlend;
if (dstAlpha == OPACITY_OPAQUE) {
srcBlend = srcAlpha;
} else {
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
dst[PIXEL_ALPHA] = newAlpha;
if (newAlpha != 0) {
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
} else {
srcBlend = srcAlpha;
}
}
int dstRed = dst[PIXEL_RED];
int dstGreen = dst[PIXEL_GREEN];
int dstBlue = dst[PIXEL_BLUE];
int srcHue;
int srcSaturation;
int srcValue;
int dstHue;
int dstSaturation;
int dstValue;
rgb_to_hsv(src[PIXEL_RED], src[PIXEL_GREEN], src[PIXEL_BLUE], &srcHue, &srcSaturation, &srcValue);
rgb_to_hsv(dstRed, dstGreen, dstBlue, &dstHue, &dstSaturation, &dstValue);
int srcRed;
int srcGreen;
int srcBlue;
hsv_to_rgb(dstHue, srcSaturation, dstValue, &srcRed, &srcGreen, &srcBlue);
dst[PIXEL_RED] = UINT8_BLEND(srcRed, dstRed, srcBlend);
dst[PIXEL_GREEN] = UINT8_BLEND(srcGreen, dstGreen, srcBlend);
dst[PIXEL_BLUE] = UINT8_BLEND(srcBlue, dstBlue, srcBlend);
}
columns--;
src += MAX_CHANNEL_RGBA;
dst += MAX_CHANNEL_RGBA;
}
rows--;
srcRowStart += srcRowStride;
dstRowStart += dstRowStride;
if(maskRowStart)
maskRowStart += maskRowStride;
}
}
void KisRgbColorSpace::compositeValue(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
{
while (rows > 0) {
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphamask
if(mask != 0)
{
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
if (opacity != OPACITY_OPAQUE) {
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
}
TQ_UINT8 srcBlend;
if (dstAlpha == OPACITY_OPAQUE) {
srcBlend = srcAlpha;
} else {
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
dst[PIXEL_ALPHA] = newAlpha;
if (newAlpha != 0) {
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
} else {
srcBlend = srcAlpha;
}
}
int dstRed = dst[PIXEL_RED];
int dstGreen = dst[PIXEL_GREEN];
int dstBlue = dst[PIXEL_BLUE];
int srcHue;
int srcSaturation;
int srcValue;
int dstHue;
int dstSaturation;
int dstValue;
rgb_to_hsv(src[PIXEL_RED], src[PIXEL_GREEN], src[PIXEL_BLUE], &srcHue, &srcSaturation, &srcValue);
rgb_to_hsv(dstRed, dstGreen, dstBlue, &dstHue, &dstSaturation, &dstValue);
int srcRed;
int srcGreen;
int srcBlue;
hsv_to_rgb(dstHue, dstSaturation, srcValue, &srcRed, &srcGreen, &srcBlue);
dst[PIXEL_RED] = UINT8_BLEND(srcRed, dstRed, srcBlend);
dst[PIXEL_GREEN] = UINT8_BLEND(srcGreen, dstGreen, srcBlend);
dst[PIXEL_BLUE] = UINT8_BLEND(srcBlue, dstBlue, srcBlend);
}
columns--;
src += MAX_CHANNEL_RGBA;
dst += MAX_CHANNEL_RGBA;
}
rows--;
srcRowStart += srcRowStride;
dstRowStart += dstRowStride;
if(maskRowStart)
maskRowStart += maskRowStride;
}
}
void KisRgbColorSpace::compositeColor(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 *maskRowStart, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 opacity)
{
while (rows > 0) {
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphamask
if(mask != 0)
{
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
if (opacity != OPACITY_OPAQUE) {
srcAlpha = UINT8_MULT(src[PIXEL_ALPHA], opacity);
}
TQ_UINT8 srcBlend;
if (dstAlpha == OPACITY_OPAQUE) {
srcBlend = srcAlpha;
} else {
TQ_UINT8 newAlpha = dstAlpha + UINT8_MULT(OPACITY_OPAQUE - dstAlpha, srcAlpha);
dst[PIXEL_ALPHA] = newAlpha;
if (newAlpha != 0) {
srcBlend = UINT8_DIVIDE(srcAlpha, newAlpha);
} else {
srcBlend = srcAlpha;
}
}
int dstRed = dst[PIXEL_RED];
int dstGreen = dst[PIXEL_GREEN];
int dstBlue = dst[PIXEL_BLUE];
int srcHue;
int srcSaturation;
int srcLightness;
int dstHue;
int dstSaturation;
int dstLightness;
rgb_to_hls(src[PIXEL_RED], src[PIXEL_GREEN], src[PIXEL_BLUE], &srcHue, &srcLightness, &srcSaturation);
rgb_to_hls(dstRed, dstGreen, dstBlue, &dstHue, &dstLightness, &dstSaturation);
TQ_UINT8 srcRed;
TQ_UINT8 srcGreen;
TQ_UINT8 srcBlue;
hls_to_rgb(srcHue, dstLightness, srcSaturation, &srcRed, &srcGreen, &srcBlue);
dst[PIXEL_RED] = UINT8_BLEND(srcRed, dstRed, srcBlend);
dst[PIXEL_GREEN] = UINT8_BLEND(srcGreen, dstGreen, srcBlend);
dst[PIXEL_BLUE] = UINT8_BLEND(srcBlue, dstBlue, srcBlend);
}
columns--;
src += MAX_CHANNEL_RGBA;
dst += MAX_CHANNEL_RGBA;
}
rows--;
srcRowStart += srcRowStride;
dstRowStart += dstRowStride;
if(maskRowStart)
maskRowStart += maskRowStride;
}
}
void KisRgbColorSpace::compositeErase(TQ_UINT8 *dst,
TQ_INT32 dstRowSize,
const TQ_UINT8 *src,
TQ_INT32 srcRowSize,
const TQ_UINT8 *srcAlphaMask,
TQ_INT32 maskRowStride,
TQ_INT32 rows,
TQ_INT32 cols,
TQ_UINT8 /*opacity*/)
{
TQ_INT32 i;
TQ_UINT8 srcAlpha;
while (rows-- > 0)
{
const TQ_UINT8 *s = src;
TQ_UINT8 *d = dst;
const TQ_UINT8 *mask = srcAlphaMask;
for (i = cols; i > 0; i--, s+=MAX_CHANNEL_RGBA, d+=MAX_CHANNEL_RGBA)
{
srcAlpha = s[PIXEL_ALPHA];
// apply the alphamask
if(mask != 0)
{
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_BLEND(srcAlpha, OPACITY_OPAQUE, *mask);
mask++;
}
d[PIXEL_ALPHA] = UINT8_MULT(srcAlpha, d[PIXEL_ALPHA]);
}
dst += dstRowSize;
if(srcAlphaMask)
srcAlphaMask += maskRowStride;
src += srcRowSize;
}
}
void KisRgbColorSpace::bitBlt(TQ_UINT8 *dst,
TQ_INT32 dstRowStride,
const TQ_UINT8 *src,
TQ_INT32 srcRowStride,
const TQ_UINT8 *mask,
TQ_INT32 maskRowStride,
TQ_UINT8 opacity,
TQ_INT32 rows,
TQ_INT32 cols,
const KisCompositeOp& op)
{
switch (op.op()) {
case COMPOSITE_UNDEF:
// Undefined == no composition
break;
case COMPOSITE_OVER:
compositeOver(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ALPHA_DARKEN:
compositeAlphaDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_IN:
compositeIn(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_OUT:
compositeOut(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_ATOP:
compositeAtop(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_XOR:
compositeXor(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_PLUS:
compositePlus(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_MINUS:
compositeMinus(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_ADD:
compositeAdd(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_SUBTRACT:
compositeSubtract(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_DIFF:
compositeDiff(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_MULT:
compositeMultiply(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DIVIDE:
compositeDivide(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BUMPMAP:
compositeBumpmap(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY:
compositeCopy(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY_RED:
compositeCopyRed(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY_GREEN:
compositeCopyGreen(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY_BLUE:
compositeCopyBlue(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY_OPACITY:
compositeCopyOpacity(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_CLEAR:
compositeClear(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_DISSOLVE:
compositeDissolve(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_DISPLACE:
compositeDisplace(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
#if 0
case COMPOSITE_MODULATE:
compositeModulate(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_THRESHOLD:
compositeThreshold(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
#endif
case COMPOSITE_NO:
// No composition.
break;
case COMPOSITE_DARKEN:
compositeDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_LIGHTEN:
compositeLighten(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_HUE:
compositeHue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_SATURATION:
compositeSaturation(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_VALUE:
compositeValue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLOR:
compositeColor(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLORIZE:
compositeColorize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_LUMINIZE:
compositeLuminize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_SCREEN:
compositeScreen(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_OVERLAY:
compositeOverlay(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ERASE:
compositeErase(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DODGE:
compositeDodge(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BURN:
compositeBurn(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
default:
break;
}
}
KisCompositeOpList KisRgbColorSpace::userVisiblecompositeOps() const
{
KisCompositeOpList list;
list.append(KisCompositeOp(COMPOSITE_OVER));
list.append(KisCompositeOp(COMPOSITE_ALPHA_DARKEN));
list.append(KisCompositeOp(COMPOSITE_MULT));
list.append(KisCompositeOp(COMPOSITE_BURN));
list.append(KisCompositeOp(COMPOSITE_DODGE));
list.append(KisCompositeOp(COMPOSITE_DIVIDE));
list.append(KisCompositeOp(COMPOSITE_SCREEN));
list.append(KisCompositeOp(COMPOSITE_OVERLAY));
list.append(KisCompositeOp(COMPOSITE_DARKEN));
list.append(KisCompositeOp(COMPOSITE_LIGHTEN));
list.append(KisCompositeOp(COMPOSITE_HUE));
list.append(KisCompositeOp(COMPOSITE_SATURATION));
list.append(KisCompositeOp(COMPOSITE_VALUE));
list.append(KisCompositeOp(COMPOSITE_COLOR));
list.append(KisCompositeOp(COMPOSITE_PLUS));
list.append(KisCompositeOp(COMPOSITE_MINUS));
list.append(KisCompositeOp(COMPOSITE_SUBTRACT));
list.append(KisCompositeOp(COMPOSITE_ADD));
return list;
}