← Back to branch summary

~smartboyhw/ubuntu/raring/calligra/2.6.0-0ubuntu1

« back to all changes in this revision

Viewing changes to libs/pigment/KoColorSpace.cpp

  • Committer: Package Import Robot
  • Author(s): Philip Muškovac
  • Date: 2012-10-23 21:09:16 UTC
  • mfrom: (1.1.13)
  • Revision ID: package-import@ubuntu.com-20121023210916-m82w6zxnxhaxz7va
Tags: 1:2.5.90-0ubuntu1
https://launchpad.net/bugs/1070436
https://launchpad.net/bugs/1071686
* New upstream alpha release (LP: #1070436)
  - Add libkactivities-dev and libopenimageio-dev to build-depends
  - Add kubuntu_build_calligraactive.diff to build calligraactive by default
  - Add package for calligraauthor and move files that are shared between
    calligrawords and calligraauthor to calligrawords-common
* Document the patches
* Remove numbers from patches so they follow the same naming scheme as
  the rest of our patches.
* calligra-data breaks replaces krita-data (<< 1:2.5.3) (LP: #1071686)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libs/pigment/KoColorSpace.cpp
177
177
const KoColorConversionTransformation* KoColorSpace::toLabA16Converter() const
178
178
{
179
179
    if (!d->transfoToLABA16) {
180
 
        d->transfoToLABA16 = KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(this, KoColorSpaceRegistry::instance()->lab16("")) ;
 
180
        d->transfoToLABA16 = KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(this, KoColorSpaceRegistry::instance()->lab16(""), KoColorConversionTransformation::IntentPerceptual, KoColorConversionTransformation::BlackpointCompensation) ;
181
181
    }
182
182
    return d->transfoToLABA16;
183
183
}
185
185
const KoColorConversionTransformation* KoColorSpace::fromLabA16Converter() const
186
186
{
187
187
    if (!d->transfoFromLABA16) {
188
 
        d->transfoFromLABA16 = KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(KoColorSpaceRegistry::instance()->lab16("") , this) ;
 
188
        d->transfoFromLABA16 = KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(KoColorSpaceRegistry::instance()->lab16(""), this, KoColorConversionTransformation::IntentPerceptual, KoColorConversionTransformation::BlackpointCompensation) ;
189
189
    }
190
190
    return d->transfoFromLABA16;
191
191
}
192
192
const KoColorConversionTransformation* KoColorSpace::toRgbA16Converter() const
193
193
{
194
194
    if (!d->transfoToRGBA16) {
195
 
        d->transfoToRGBA16 = KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(this, KoColorSpaceRegistry::instance()->rgb16("")) ;
 
195
        d->transfoToRGBA16 = KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(this, KoColorSpaceRegistry::instance()->rgb16(""), KoColorConversionTransformation::IntentPerceptual, KoColorConversionTransformation::BlackpointCompensation) ;
196
196
    }
197
197
    return d->transfoToRGBA16;
198
198
}
199
199
const KoColorConversionTransformation* KoColorSpace::fromRgbA16Converter() const
200
200
{
201
201
    if (!d->transfoFromRGBA16) {
202
 
        d->transfoFromRGBA16 = KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(KoColorSpaceRegistry::instance()->rgb16("") , this) ;
 
202
        d->transfoFromRGBA16 = KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(KoColorSpaceRegistry::instance()->rgb16("") , this, KoColorConversionTransformation::IntentPerceptual, KoColorConversionTransformation::BlackpointCompensation) ;
203
203
    }
204
204
    return d->transfoFromRGBA16;
205
205
}
224
224
    fromRgbA16Converter()->transform(src, dst, nPixels);
225
225
}
226
226
 
227
 
KoColorConversionTransformation* KoColorSpace::createColorConverter(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent) const
 
227
KoColorConversionTransformation* KoColorSpace::createColorConverter(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
228
228
{
229
229
    if (*this == *dstColorSpace) {
230
230
        return new KoCopyColorConversionTransformation(this);
231
231
    } else {
232
 
        return KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(this, dstColorSpace, renderingIntent);
 
232
        return KoColorSpaceRegistry::instance()->colorConversionSystem()->createColorConverter(this, dstColorSpace, renderingIntent, conversionFlags);
233
233
    }
234
234
}
235
235
 
237
237
                                   quint8 * dst,
238
238
                                   const KoColorSpace * dstColorSpace,
239
239
                                   quint32 numPixels,
240
 
                                   KoColorConversionTransformation::Intent renderingIntent) const
 
240
                                   KoColorConversionTransformation::Intent renderingIntent,
 
241
                                   KoColorConversionTransformation::ConversionFlags conversionFlags) const
241
242
{
242
243
    if (*this == *dstColorSpace) {
243
244
        memcpy(dst, src, numPixels * sizeof(quint8) * pixelSize());
244
245
    } else {
245
 
        KoCachedColorConversionTransformation cct = KoColorSpaceRegistry::instance()->colorConversionCache()->cachedConverter(this, dstColorSpace, renderingIntent);
 
246
        KoCachedColorConversionTransformation cct = KoColorSpaceRegistry::instance()->colorConversionCache()->cachedConverter(this, dstColorSpace, renderingIntent, conversionFlags);
246
247
        cct.transformation()->transform(src, dst, numPixels);
247
248
    }
248
249
    return true;
249
250
}
250
251
 
251
252
 
252
 
void KoColorSpace::bitBlt(quint8* dst,
253
 
                          qint32 dststride,
254
 
                          const KoColorSpace* srcSpace,
255
 
                          const quint8* src,
256
 
                          qint32 srcRowStride,
257
 
                          const quint8* srcAlphaMask,
258
 
                          qint32 maskRowStride,
259
 
                          quint8 opacity,
260
 
                          qint32 rows,
261
 
                          qint32 cols,
262
 
                          const QString& op,
263
 
                          const QBitArray& channelFlags) const
264
 
{
265
 
    if (d->compositeOps.contains(op)) {
266
 
        bitBlt(dst, dststride, srcSpace, src, srcRowStride, srcAlphaMask, maskRowStride, opacity, rows, cols, d->compositeOps.value(op), channelFlags);
267
 
    } else {
268
 
        bitBlt(dst, dststride, srcSpace, src, srcRowStride, srcAlphaMask, maskRowStride, opacity, rows, cols, d->compositeOps.value(COMPOSITE_OVER), channelFlags);
269
 
    }
270
 
 
271
 
}
272
 
 
273
 
void KoColorSpace::bitBlt(quint8* dst,
274
 
                          qint32 dstRowStride,
275
 
                          const KoColorSpace* srcSpace,
276
 
                          const quint8* src,
277
 
                          qint32 srcRowStride,
278
 
                          const quint8 *srcAlphaMask,
279
 
                          qint32 maskRowStride,
280
 
                          quint8 opacity,
281
 
                          qint32 rows,
282
 
                          qint32 cols,
283
 
                          const KoCompositeOp* op,
284
 
                          const QBitArray& channelFlags) const
285
 
{
286
 
    Q_ASSERT_X(*op->colorSpace() == *this, "KoColorSpace::bitBlt", QString("Composite op is for color space %1 (%2) while this is %3 (%4)").arg(op->colorSpace()->id()).arg(op->colorSpace()->profile()->name()).arg(id()).arg(profile()->name()).toLatin1());
287
 
 
288
 
    if (rows <= 0 || cols <= 0)
289
 
        return;
290
 
 
291
 
    if (!(*this == *srcSpace)) {
292
 
 
293
 
        quint32 conversionBufferStride = cols * pixelSize();
294
 
        QVector<quint8> * conversionCache =
295
 
            threadLocalConversionCache(rows * conversionBufferStride);
296
 
 
297
 
        quint8* conversionData = conversionCache->data();
298
 
 
299
 
        for (qint32 row = 0; row < rows; row++) {
300
 
            srcSpace->convertPixelsTo(src + row * srcRowStride,
301
 
                                      conversionData + row * conversionBufferStride,
302
 
                                      this, cols);
303
 
        }
304
 
 
305
 
        op->composite(dst, dstRowStride,
306
 
                      conversionData, conversionBufferStride,
307
 
                      srcAlphaMask, maskRowStride,
308
 
                      rows,  cols,
309
 
                      opacity, channelFlags);
310
 
    } else {
311
 
        op->composite(dst, dstRowStride,
312
 
                      src, srcRowStride,
313
 
                      srcAlphaMask, maskRowStride,
314
 
                      rows,  cols,
315
 
                      opacity, channelFlags);
316
 
    }
317
 
 
318
 
}
319
 
 
320
 
void KoColorSpace::bitBlt(const KoColorSpace* srcSpace, const KoCompositeOp::ParameterInfo& params, const KoCompositeOp* op) const
321
 
{
322
 
    Q_ASSERT_X(*op->colorSpace() == *this, "KoColorSpace::bitBlt", QString("Composite op is for color space %1 (%2) while this is %3 (%4)").arg(op->colorSpace()->id()).arg(op->colorSpace()->profile()->name()).arg(id()).arg(profile()->name()).toLatin1());
323
 
    
 
253
void KoColorSpace::bitBlt(const KoColorSpace* srcSpace, const KoCompositeOp::ParameterInfo& params, const KoCompositeOp* op,
 
254
                          KoColorConversionTransformation::Intent renderingIntent,
 
255
                          KoColorConversionTransformation::ConversionFlags conversionFlags) const
 
256
{
 
257
    Q_ASSERT_X(*op->colorSpace() == *this, "KoColorSpace::bitBlt", QString("Composite op is for color space %1 (%2) while this is %3 (%4)").arg(op->colorSpace()->id()).arg(op->colorSpace()->profile()->name()).arg(id()).arg(profile()->name()).toLatin1());
 
258
 
324
259
    if(params.rows <= 0 || params.cols <= 0)
325
260
        return;
326
 
    
 
261
 
327
262
    if(!(*this == *srcSpace)) {
328
263
        quint32           conversionBufferStride = params.cols * pixelSize();
329
264
        QVector<quint8> * conversionCache        = threadLocalConversionCache(params.rows * conversionBufferStride);
330
265
        quint8*           conversionData         = conversionCache->data();
331
 
        
 
266
 
332
267
        for(qint32 row=0; row<params.rows; row++) {
333
 
            srcSpace->convertPixelsTo(params.srcRowStart + row*params.srcRowStride    ,
334
 
                                      conversionData     + row*conversionBufferStride, this, params.cols);
 
268
            srcSpace->convertPixelsTo(params.srcRowStart + row*params.srcRowStride,
 
269
                                      conversionData     + row*conversionBufferStride, this, params.cols,
 
270
                                      renderingIntent, conversionFlags);
335
271
        }
336
 
        
 
272
 
337
273
        KoCompositeOp::ParameterInfo paramInfo(params);
338
274
        paramInfo.srcRowStart  = conversionData;
339
275
        paramInfo.srcRowStride = conversionBufferStride;
380
316
 
381
317
QImage KoColorSpace::convertToQImage(const quint8 *data, qint32 width, qint32 height,
382
318
                                     const KoColorProfile *dstProfile,
383
 
                                     KoColorConversionTransformation::Intent renderingIntent) const
 
319
                                     KoColorConversionTransformation::Intent renderingIntent,
 
320
                                     KoColorConversionTransformation::ConversionFlags conversionFlags) const
384
321
 
385
322
{
386
323
    QImage img = QImage(width, height, QImage::Format_ARGB32);
388
325
    const KoColorSpace * dstCS = KoColorSpaceRegistry::instance()->rgb8(dstProfile);
389
326
 
390
327
    if (data)
391
 
        this->convertPixelsTo(const_cast<quint8 *>(data), img.bits(), dstCS, width * height, renderingIntent);
 
328
        this->convertPixelsTo(const_cast<quint8 *>(data), img.bits(), dstCS, width * height, renderingIntent, conversionFlags);
392
329
 
393
330
    return img;
394
331
}