Changeset 47099 in webkit


Ignore:
Timestamp:
Aug 12, 2009 3:11:03 AM (15 years ago)
Author:
krit@webkit.org
Message:

2009-08-12 Dirk Schulze <​krit@webkit.org>

Reviewed by Oliver Hunt.

SVG Filter premultiplied color support for getImageDate/putImageData
​https://bugs.webkit.org/show_bug.cgi?id=27933

Some SVG Filters need premultiplied ImageData for the calculation. Therefore getImageData
and putImageData of ImageBuffer need support for premultiplied colors.

  • html/CanvasRenderingContext2D.cpp: (WebCore::CanvasRenderingContext2D::getImageData): (WebCore::CanvasRenderingContext2D::putImageData):
  • platform/graphics/ImageBuffer.h: (WebCore::):
  • platform/graphics/cairo/ImageBufferCairo.cpp: (WebCore::getImageData): (WebCore::ImageBuffer::getUnmultipliedImageData): (WebCore::ImageBuffer::getPremultipliedImageData): (WebCore::putImageData): (WebCore::ImageBuffer::putUnmultipliedImageData): (WebCore::ImageBuffer::putPremultipliedImageData):
  • platform/graphics/cg/ImageBufferCG.cpp: (WebCore::getImageData): (WebCore::ImageBuffer::getUnmultipliedImageData): (WebCore::ImageBuffer::getPremultipliedImageData): (WebCore::putImageData): (WebCore::ImageBuffer::putUnmultipliedImageData): (WebCore::ImageBuffer::putPremultipliedImageData):
  • platform/graphics/qt/ImageBufferQt.cpp: (WebCore::getImageData): (WebCore::ImageBuffer::getUnmultipliedImageData): (WebCore::ImageBuffer::getPremultipliedImageData): (WebCore::putImageData): (WebCore::ImageBuffer::putUnmultipliedImageData): (WebCore::ImageBuffer::putPremultipliedImageData):
  • platform/graphics/skia/ImageBufferSkia.cpp: (WebCore::getImageData): (WebCore::ImageBuffer::getUnmultipliedImageData): (WebCore::ImageBuffer::getPremultipliedImageData): (WebCore::putImageData): (WebCore::ImageBuffer::putUnmultipliedImageData): (WebCore::ImageBuffer::putPremultipliedImageData):
  • platform/graphics/wx/ImageBufferWx.cpp: (WebCore::ImageBuffer::getUnmultipliedImageData): (WebCore::ImageBuffer::getPremultipliedImageData): (WebCore::ImageBuffer::putUnmultipliedImageData): (WebCore::ImageBuffer::putPremultipliedImageData):
  • svg/graphics/SVGResourceMasker.cpp: (WebCore::SVGResourceMasker::applyMask):
Location:
trunk/WebCore
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r47095 r47099  
     12009-08-12  Dirk Schulze  <krit@webkit.org>
     2
     3        Reviewed by Oliver Hunt.
     4
     5        SVG Filter premultiplied color support for getImageDate/putImageData
     6        [https://bugs.webkit.org/show_bug.cgi?id=27933]
     7
     8        Some SVG Filters need premultiplied ImageData for the calculation. Therefore getImageData
     9        and putImageData of ImageBuffer need support for premultiplied colors.
     10
     11        * html/CanvasRenderingContext2D.cpp:
     12        (WebCore::CanvasRenderingContext2D::getImageData):
     13        (WebCore::CanvasRenderingContext2D::putImageData):
     14        * platform/graphics/ImageBuffer.h:
     15        (WebCore::):
     16        * platform/graphics/cairo/ImageBufferCairo.cpp:
     17        (WebCore::getImageData):
     18        (WebCore::ImageBuffer::getUnmultipliedImageData):
     19        (WebCore::ImageBuffer::getPremultipliedImageData):
     20        (WebCore::putImageData):
     21        (WebCore::ImageBuffer::putUnmultipliedImageData):
     22        (WebCore::ImageBuffer::putPremultipliedImageData):
     23        * platform/graphics/cg/ImageBufferCG.cpp:
     24        (WebCore::getImageData):
     25        (WebCore::ImageBuffer::getUnmultipliedImageData):
     26        (WebCore::ImageBuffer::getPremultipliedImageData):
     27        (WebCore::putImageData):
     28        (WebCore::ImageBuffer::putUnmultipliedImageData):
     29        (WebCore::ImageBuffer::putPremultipliedImageData):
     30        * platform/graphics/qt/ImageBufferQt.cpp:
     31        (WebCore::getImageData):
     32        (WebCore::ImageBuffer::getUnmultipliedImageData):
     33        (WebCore::ImageBuffer::getPremultipliedImageData):
     34        (WebCore::putImageData):
     35        (WebCore::ImageBuffer::putUnmultipliedImageData):
     36        (WebCore::ImageBuffer::putPremultipliedImageData):
     37        * platform/graphics/skia/ImageBufferSkia.cpp:
     38        (WebCore::getImageData):
     39        (WebCore::ImageBuffer::getUnmultipliedImageData):
     40        (WebCore::ImageBuffer::getPremultipliedImageData):
     41        (WebCore::putImageData):
     42        (WebCore::ImageBuffer::putUnmultipliedImageData):
     43        (WebCore::ImageBuffer::putPremultipliedImageData):
     44        * platform/graphics/wx/ImageBufferWx.cpp:
     45        (WebCore::ImageBuffer::getUnmultipliedImageData):
     46        (WebCore::ImageBuffer::getPremultipliedImageData):
     47        (WebCore::ImageBuffer::putUnmultipliedImageData):
     48        (WebCore::ImageBuffer::putPremultipliedImageData):
     49        * svg/graphics/SVGResourceMasker.cpp:
     50        (WebCore::SVGResourceMasker::applyMask):
     51
    1522009-08-12  Mikhail Naganov  <mnaganov@chromium.org>
    253

  • trunk/WebCore/html/canvas/CanvasRenderingContext2D.cpp

    r46956 r47099  
    13071307    if (!buffer)
    13081308        return createEmptyImageData(scaledRect.size());
    1309     return buffer->getImageData(scaledRect);
     1309    return buffer->getUnmultipliedImageData(scaledRect);
    13101310}
    13111311
    … …  
    13581358    IntPoint destPoint(destOffset.width(), destOffset.height());
    13591359   
    1360     buffer->putImageData(data, sourceRect, destPoint);
     1360    buffer->putUnmultipliedImageData(data, sourceRect, destPoint);
    13611361}
    13621362

  • trunk/WebCore/platform/graphics/ImageBuffer.h

    r46956 r47099  
    5151    };
    5252
     53    enum Multiply {
     54        Premultiplied,
     55        Unmultiplied
     56    };
     57
    5358    class ImageBuffer : public Noncopyable {
    5459    public:
    … …  
    7277        void clearImage() { m_image.clear(); }
    7378
    74         PassRefPtr<ImageData> getImageData(const IntRect& rect) const;
    75         void putImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint);
     79        PassRefPtr<ImageData> getUnmultipliedImageData(const IntRect&) const;
     80        PassRefPtr<ImageData> getPremultipliedImageData(const IntRect&) const;
     81
     82        void putUnmultipliedImageData(ImageData*, const IntRect& sourceRect, const IntPoint& destPoint);
     83        void putPremultipliedImageData(ImageData*, const IntRect& sourceRect, const IntPoint& destPoint);
    7684
    7785        String toDataURL(const String& mimeType) const;

  • trunk/WebCore/platform/graphics/cairo/ImageBufferCairo.cpp

    r46956 r47099  
    139139}
    140140
    141 PassRefPtr<ImageData> ImageBuffer::getImageData(const IntRect& rect) const
    142 {
    143     ASSERT(cairo_surface_get_type(m_data.m_surface) == CAIRO_SURFACE_TYPE_IMAGE);
     141template <Multiply multiplied>
     142PassRefPtr<ImageData> getImageData(const IntRect& rect, const ImageBufferData& data, const IntSize& size)
     143{
     144    ASSERT(cairo_surface_get_type(data.m_surface) == CAIRO_SURFACE_TYPE_IMAGE);
    144145
    145146    PassRefPtr<ImageData> result = ImageData::create(rect.width(), rect.height());
    146     unsigned char* dataSrc = cairo_image_surface_get_data(m_data.m_surface);
     147    unsigned char* dataSrc = cairo_image_surface_get_data(data.m_surface);
    147148    unsigned char* dataDst = result->data()->data()->data();
    148149
    149     if (rect.x() < 0 || rect.y() < 0 || (rect.x() + rect.width()) > m_size.width() || (rect.y() + rect.height()) > m_size.height())
     150    if (rect.x() < 0 || rect.y() < 0 || (rect.x() + rect.width()) > size.width() || (rect.y() + rect.height()) > size.height())
    150151        memset(dataSrc, 0, result->data()->length());
    151152
    … …  
    157158    }
    158159    int endx = rect.x() + rect.width();
    159     if (endx > m_size.width())
    160         endx = m_size.width();
     160    if (endx > size.width())
     161        endx = size.width();
    161162    int numColumns = endx - originx;
    162163
    … …  
    168169    }
    169170    int endy = rect.y() + rect.height();
    170     if (endy > m_size.height())
    171         endy = m_size.height();
     171    if (endy > size.height())
     172        endy = size.height();
    172173    int numRows = endy - originy;
    173174
    174     int stride = cairo_image_surface_get_stride(m_data.m_surface);
     175    int stride = cairo_image_surface_get_stride(data.m_surface);
    175176    unsigned destBytesPerRow = 4 * rect.width();
    176177
    … …  
    181182            int basex = x * 4;
    182183            unsigned* pixel = row + x + originx;
    183             Color pixelColor = colorFromPremultipliedARGB(*pixel);
     184            Color pixelColor;
     185            if (multiplied == Unmultiplied)
     186                pixelColor = colorFromPremultipliedARGB(*pixel);
     187            else
     188                pixelColor = Color(*pixel);
    184189            destRows[basex]     = pixelColor.red();
    185190            destRows[basex + 1] = pixelColor.green();
    … …  
    193198}
    194199
    195 void ImageBuffer::putImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
    196 {
    197     ASSERT(cairo_surface_get_type(m_data.m_surface) == CAIRO_SURFACE_TYPE_IMAGE);
    198 
    199     unsigned char* dataDst = cairo_image_surface_get_data(m_data.m_surface);
     200PassRefPtr<ImageData> ImageBuffer::getUnmultipliedImageData(const IntRect& rect) const
     201{
     202    return getImageData<Unmultiplied>(rect, m_data, m_size);
     203}
     204
     205PassRefPtr<ImageData> ImageBuffer::getPremultipliedImageData(const IntRect& rect) const
     206{
     207    return getImageData<Premultiplied>(rect, m_data, m_size);
     208}
     209
     210template <Multiply multiplied>
     211void putImageData(ImageData*& source, const IntRect& sourceRect, const IntPoint& destPoint, ImageBufferData& data, const IntSize& size)
     212{
     213    ASSERT(cairo_surface_get_type(data.m_surface) == CAIRO_SURFACE_TYPE_IMAGE);
     214
     215    unsigned char* dataDst = cairo_image_surface_get_data(data.m_surface);
    200216
    201217    ASSERT(sourceRect.width() > 0);
    … …  
    205221    int destx = destPoint.x() + sourceRect.x();
    206222    ASSERT(destx >= 0);
    207     ASSERT(destx < m_size.width());
     223    ASSERT(destx < size.width());
    208224    ASSERT(originx >= 0);
    209225    ASSERT(originx <= sourceRect.right());
    210226
    211227    int endx = destPoint.x() + sourceRect.right();
    212     ASSERT(endx <= m_size.width());
     228    ASSERT(endx <= size.width());
    213229
    214230    int numColumns = endx - destx;
    … …  
    217233    int desty = destPoint.y() + sourceRect.y();
    218234    ASSERT(desty >= 0);
    219     ASSERT(desty < m_size.height());
     235    ASSERT(desty < size.height());
    220236    ASSERT(originy >= 0);
    221237    ASSERT(originy <= sourceRect.bottom());
    222238
    223239    int endy = destPoint.y() + sourceRect.bottom();
    224     ASSERT(endy <= m_size.height());
     240    ASSERT(endy <= size.height());
    225241    int numRows = endy - desty;
    226242
    227243    unsigned srcBytesPerRow = 4 * source->width();
    228     int stride = cairo_image_surface_get_stride(m_data.m_surface);
     244    int stride = cairo_image_surface_get_stride(data.m_surface);
    229245
    230246    unsigned char* srcRows = source->data()->data()->data() + originy * srcBytesPerRow + originx * 4;
    … …  
    238254                    srcRows[basex + 2],
    239255                    srcRows[basex + 3]);
    240             *pixel = premultipliedARGBFromColor(pixelColor);
     256            if (multiplied == Unmultiplied)
     257                *pixel = premultipliedARGBFromColor(pixelColor);
     258            else
     259                *pixel = pixelColor.rgb();
    241260        }
    242261        srcRows += srcBytesPerRow;
    243262    }
     263}
     264
     265void ImageBuffer::putUnmultipliedImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
     266{
     267    putImageData<Unmultiplied>(source, sourceRect, destPoint, m_data, m_size);
     268}
     269
     270void ImageBuffer::putPremultipliedImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
     271{
     272    putImageData<Premultiplied>(source, sourceRect, destPoint, m_data, m_size);
    244273}
    245274

  • trunk/WebCore/platform/graphics/cg/ImageBufferCG.cpp

    r47092 r47099  
    125125}
    126126
    127 PassRefPtr<ImageData> ImageBuffer::getImageData(const IntRect& rect) const
     127template <Multiply multiplied>
     128PassRefPtr<ImageData> getImageData(const IntRect& rect, const ImageBufferData& imageData, const IntSize& size)
    128129{
    129130    PassRefPtr<ImageData> result = ImageData::create(rect.width(), rect.height());
    130131    unsigned char* data = result->data()->data()->data();
    131132
    132     if (rect.x() < 0 || rect.y() < 0 || (rect.x() + rect.width()) > m_size.width() || (rect.y() + rect.height()) > m_size.height())
     133    if (rect.x() < 0 || rect.y() < 0 || (rect.x() + rect.width()) > size.width() || (rect.y() + rect.height()) > size.height())
    133134        memset(data, 0, result->data()->length());
    134135
    … …  
    140141    }
    141142    int endx = rect.x() + rect.width();
    142     if (endx > m_size.width())
    143         endx = m_size.width();
     143    if (endx > size.width())
     144        endx = size.width();
    144145    int numColumns = endx - originx;
    145146
    … …  
    151152    }
    152153    int endy = rect.y() + rect.height();
    153     if (endy > m_size.height())
    154         endy = m_size.height();
     154    if (endy > size.height())
     155        endy = size.height();
    155156    int numRows = endy - originy;
    156157
    157     unsigned srcBytesPerRow = 4 * m_size.width();
     158    unsigned srcBytesPerRow = 4 * size.width();
    158159    unsigned destBytesPerRow = 4 * rect.width();
    159160
    160161    // ::create ensures that all ImageBuffers have valid data, so we don't need to check it here.
    161     unsigned char* srcRows = reinterpret_cast<unsigned char*>(m_data.m_data) + originy * srcBytesPerRow + originx * 4;
     162    unsigned char* srcRows = reinterpret_cast<unsigned char*>(imageData.m_data) + originy * srcBytesPerRow + originx * 4;
    162163    unsigned char* destRows = data + desty * destBytesPerRow + destx * 4;
    163164    for (int y = 0; y < numRows; ++y) {
    164165        for (int x = 0; x < numColumns; x++) {
    165166            int basex = x * 4;
    166             if (unsigned char alpha = srcRows[basex + 3]) {
     167            unsigned char alpha = srcRows[basex + 3];
     168            if (multiplied == Unmultiplied && alpha) {
    167169                destRows[basex] = (srcRows[basex] * 255) / alpha;
    168170                destRows[basex + 1] = (srcRows[basex + 1] * 255) / alpha;
    … …  
    178180}
    179181
    180 void ImageBuffer::putImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
     182PassRefPtr<ImageData> ImageBuffer::getUnmultipliedImageData(const IntRect& rect) const
     183{
     184    return getImageData<Unmultiplied>(rect, m_data, m_size);
     185}
     186
     187PassRefPtr<ImageData> ImageBuffer::getPremultipliedImageData(const IntRect& rect) const
     188{
     189    return getImageData<Premultiplied>(rect, m_data, m_size);
     190}
     191
     192template <Multiply multiplied>
     193void putImageData(ImageData*& source, const IntRect& sourceRect, const IntPoint& destPoint, ImageBufferData& imageData, const IntSize& size)
    181194{
    182195    ASSERT(sourceRect.width() > 0);
    … …  
    186199    int destx = destPoint.x() + sourceRect.x();
    187200    ASSERT(destx >= 0);
    188     ASSERT(destx < m_size.width());
     201    ASSERT(destx < size.width());
    189202    ASSERT(originx >= 0);
    190203    ASSERT(originx <= sourceRect.right());
    191204
    192205    int endx = destPoint.x() + sourceRect.right();
    193     ASSERT(endx <= m_size.width());
     206    ASSERT(endx <= size.width());
    194207
    195208    int numColumns = endx - destx;
    … …  
    198211    int desty = destPoint.y() + sourceRect.y();
    199212    ASSERT(desty >= 0);
    200     ASSERT(desty < m_size.height());
     213    ASSERT(desty < size.height());
    201214    ASSERT(originy >= 0);
    202215    ASSERT(originy <= sourceRect.bottom());
    203216
    204217    int endy = destPoint.y() + sourceRect.bottom();
    205     ASSERT(endy <= m_size.height());
     218    ASSERT(endy <= size.height());
    206219    int numRows = endy - desty;
    207220
    208221    unsigned srcBytesPerRow = 4 * source->width();
    209     unsigned destBytesPerRow = 4 * m_size.width();
     222    unsigned destBytesPerRow = 4 * size.width();
    210223
    211224    unsigned char* srcRows = source->data()->data()->data() + originy * srcBytesPerRow + originx * 4;
    212     unsigned char* destRows = reinterpret_cast<unsigned char*>(m_data.m_data) + desty * destBytesPerRow + destx * 4;
     225    unsigned char* destRows = reinterpret_cast<unsigned char*>(imageData.m_data) + desty * destBytesPerRow + destx * 4;
    213226    for (int y = 0; y < numRows; ++y) {
    214227        for (int x = 0; x < numColumns; x++) {
    215228            int basex = x * 4;
    216229            unsigned char alpha = srcRows[basex + 3];
    217             if (alpha != 255) {
     230            if (multiplied == Unmultiplied && alpha != 255) {
    218231                destRows[basex] = (srcRows[basex] * alpha + 254) / 255;
    219232                destRows[basex + 1] = (srcRows[basex + 1] * alpha + 254) / 255;
    … …  
    228241}
    229242
     243void ImageBuffer::putUnmultipliedImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
     244{
     245    putImageData<Unmultiplied>(source, sourceRect, destPoint, m_data, m_size);
     246}
     247
     248void ImageBuffer::putPremultipliedImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
     249{
     250    putImageData<Premultiplied>(source, sourceRect, destPoint, m_data, m_size);
     251}
     252
    230253static RetainPtr<CFStringRef> utiFromMIMEType(const String& mimeType)
    231254{

  • trunk/WebCore/platform/graphics/qt/ImageBufferQt.cpp

    r46956 r47099  
    126126}
    127127
    128 PassRefPtr<ImageData> ImageBuffer::getImageData(const IntRect& rect) const
     128template <Multiply multiplied>
     129PassRefPtr<ImageData> getImageData(const IntRect& rect, const ImageBufferData& imageData, const IntSize& size)
    129130{
    130131    PassRefPtr<ImageData> result = ImageData::create(rect.width(), rect.height());
    131132    unsigned char* data = result->data()->data()->data();
    132133
    133     if (rect.x() < 0 || rect.y() < 0 || (rect.x() + rect.width()) > m_size.width() || (rect.y() + rect.height()) > m_size.height())
     134    if (rect.x() < 0 || rect.y() < 0 || (rect.x() + rect.width()) > size.width() || (rect.y() + rect.height()) > size.height())
    134135        memset(data, 0, result->data()->length());
    135136
    … …  
    141142    }
    142143    int endx = rect.x() + rect.width();
    143     if (endx > m_size.width())
    144         endx = m_size.width();
     144    if (endx > size.width())
     145        endx = size.width();
    145146    int numColumns = endx - originx;
    146147
    … …  
    152153    }
    153154    int endy = rect.y() + rect.height();
    154     if (endy > m_size.height())
    155         endy = m_size.height();
     155    if (endy > size.height())
     156        endy = size.height();
    156157    int numRows = endy - originy;
    157158
    158     QImage image = m_data.m_pixmap.toImage().convertToFormat(QImage::Format_ARGB32);
     159    QImage image = imageData.m_pixmap.toImage();
     160    if (multiplied == Unmultiplied)
     161        image = image.convertToFormat(QImage::Format_ARGB32);
     162    else
     163        image = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
     164
    159165    ASSERT(!image.isNull());
    160166
    … …  
    177183}
    178184
    179 void ImageBuffer::putImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
     185PassRefPtr<ImageData> ImageBuffer::getUnmultipliedImageData(const IntRect& rect) const
     186{
     187    return getImageData<Unmultiplied>(rect, m_data, m_size);
     188}
     189
     190PassRefPtr<ImageData> ImageBuffer::getPremultipliedImageData(const IntRect& rect) const
     191{
     192    return getImageData<Premultiplied>(rect, m_data, m_size);
     193}
     194
     195template <Multiply multiplied>
     196void putImageData(ImageData*& source, const IntRect& sourceRect, const IntPoint& destPoint, ImageBufferData& data, const IntSize& size)
    180197{
    181198    ASSERT(sourceRect.width() > 0);
    … …  
    185202    int destx = destPoint.x() + sourceRect.x();
    186203    ASSERT(destx >= 0);
    187     ASSERT(destx < m_size.width());
     204    ASSERT(destx < size.width());
    188205    ASSERT(originx >= 0);
    189206    ASSERT(originx <= sourceRect.right());
    190207
    191208    int endx = destPoint.x() + sourceRect.right();
    192     ASSERT(endx <= m_size.width());
     209    ASSERT(endx <= size.width());
    193210
    194211    int numColumns = endx - destx;
    … …  
    197214    int desty = destPoint.y() + sourceRect.y();
    198215    ASSERT(desty >= 0);
    199     ASSERT(desty < m_size.height());
     216    ASSERT(desty < size.height());
    200217    ASSERT(originy >= 0);
    201218    ASSERT(originy <= sourceRect.bottom());
    202219
    203220    int endy = destPoint.y() + sourceRect.bottom();
    204     ASSERT(endy <= m_size.height());
     221    ASSERT(endy <= size.height());
    205222    int numRows = endy - desty;
    206223
    207224    unsigned srcBytesPerRow = 4 * source->width();
    208225
    209     bool isPainting = m_data.m_painter->isActive();
    210     if (isPainting)
    211         m_data.m_painter->end();
    212 
    213     QImage image = m_data.m_pixmap.toImage().convertToFormat(QImage::Format_ARGB32);
     226    bool isPainting = data.m_painter->isActive();
     227    if (isPainting)
     228        data.m_painter->end();
     229
     230    QImage image = data.m_pixmap.toImage();
     231    if (multiplied == Unmultiplied)
     232        image = image.convertToFormat(QImage::Format_ARGB32);
     233    else
     234        image = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
    214235
    215236    unsigned char* srcRows = source->data()->data()->data() + originy * srcBytesPerRow + originx * 4;
    … …  
    224245    }
    225246
    226     m_data.m_pixmap = QPixmap::fromImage(image);
    227 
    228     if (isPainting)
    229         m_data.m_painter->begin(&m_data.m_pixmap);
     247    data.m_pixmap = QPixmap::fromImage(image);
     248
     249    if (isPainting)
     250        data.m_painter->begin(&data.m_pixmap);
     251}
     252
     253void ImageBuffer::putUnmultipliedImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
     254{
     255    putImageData<Unmultiplied>(source, sourceRect, destPoint, m_data, m_size);
     256}
     257
     258void ImageBuffer::putPremultipliedImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
     259{
     260    putImageData<Premultiplied>(source, sourceRect, destPoint, m_data, m_size);
    230261}
    231262

  • trunk/WebCore/platform/graphics/skia/ImageBufferSkia.cpp

    r46956 r47099  
    119119}
    120120
    121 PassRefPtr<ImageData> ImageBuffer::getImageData(const IntRect& rect) const
     121template <Multiply multiplied>
     122PassRefPtr<ImageData> getImageData(const IntRect& rect, const SkBitmap& bitmap,
     123                                   const IntSize& size)
    122124{
    123125    ASSERT(context());
    … …  
    153155    int numRows = endY - originY;
    154156
    155     const SkBitmap& bitmap = *context()->platformContext()->bitmap();
    156157    ASSERT(bitmap.config() == SkBitmap::kARGB_8888_Config);
    157158    SkAutoLockPixels bitmapLock(bitmap);
    … …  
    163164        uint32_t* srcRow = bitmap.getAddr32(originX, originY + y);
    164165        for (int x = 0; x < numColumns; ++x) {
     166            // TODO: Support for premultiplied colors
    165167            SkColor color = SkPMColorToColor(srcRow[x]);
    166168            unsigned char* destPixel = &destRow[x * 4];
    … …  
    176178}
    177179
    178 void ImageBuffer::putImageData(ImageData* source, const IntRect& sourceRect,
    179                                const IntPoint& destPoint)
     180PassRefPtr<ImageData> ImageBuffer::getUnmultipliedImageData(const IntRect& rect) const
     181{
     182    return getImageData<Unmultiplied>(rect, *context()->platformContext()->bitmap(), m_size);
     183}
     184
     185PassRefPtr<ImageData> ImageBuffer::getPremultipliedImageData(const IntRect& rect) const
     186{
     187    return getImageData<Premultiplied>(rect, *context()->platformContext()->bitmap(), m_size);
     188}
     189
     190template <Multiply multiplied>
     191void putImageData(ImageData*& source, const IntRect& sourceRect, const IntPoint& destPoint,
     192                  const SkBitmap& bitmap, const IntSize& size)
    180193{
    181194    ASSERT(sourceRect.width() > 0);
    … …  
    205218    int numRows = endY - destY;
    206219
    207     const SkBitmap& bitmap = *context()->platformContext()->bitmap();
    208220    ASSERT(bitmap.config() == SkBitmap::kARGB_8888_Config);
    209221    SkAutoLockPixels bitmapLock(bitmap);
    … …  
    216228        uint32_t* destRow = bitmap.getAddr32(destX, destY + y);
    217229        for (int x = 0; x < numColumns; ++x) {
     230            // TODO: Support for premultiplied colors
    218231            const unsigned char* srcPixel = &srcRow[x * 4];
    219232            destRow[x] = SkPreMultiplyARGB(srcPixel[3], srcPixel[0],
    … …  
    224237}
    225238
     239void ImageBuffer::putUnmultipliedImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
     240{
     241    putImageData<Unmultiplied>(source, sourceRect, destPoint, *context()->platformContext()->bitmap(), m_size);
     242}
     243
     244void ImageBuffer::putPremultipliedImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
     245{
     246    putImageData<Premultiplied>(source, sourceRect, destPoint, *context()->platformContext()->bitmap(), m_size);
     247}
     248
    226249String ImageBuffer::toDataURL(const String&) const
    227250{

  • trunk/WebCore/platform/graphics/wx/ImageBufferWx.cpp

    r46956 r47099  
    5454}
    5555
    56 PassRefPtr<ImageData> ImageBuffer::getImageData(const IntRect&) const
     56PassRefPtr<ImageData> ImageBuffer::getUnmultipliedImageData(const IntRect& rect) const
    5757{
    5858    notImplemented();
    … …  
    6060}
    6161
    62 void ImageBuffer::putImageData(ImageData*, const IntRect&, const IntPoint&)
     62PassRefPtr<ImageData> ImageBuffer::getPremultipliedImageData(const IntRect& rect) const
     63{
     64    notImplemented();
     65    return 0;
     66}
     67
     68void ImageBuffer::putUnmultipliedImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
     69{
     70    notImplemented();
     71}
     72
     73void ImageBuffer::putPremultipliedImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
    6374{
    6475    notImplemented();

  • trunk/WebCore/svg/graphics/SVGResourceMasker.cpp

    r46956 r47099  
    7777        return;
    7878
    79     PassRefPtr<CanvasPixelArray> srcPixelArray(m_mask->getImageData(intImageRect)->data());
    80     PassRefPtr<ImageData> destImageData(luminancedImage->getImageData(intImageRect));
     79    PassRefPtr<CanvasPixelArray> srcPixelArray(m_mask->getUnmultipliedImageData(intImageRect)->data());
     80    PassRefPtr<ImageData> destImageData(luminancedImage->getUnmultipliedImageData(intImageRect));
    8181
    8282    for (unsigned pixelOffset = 0; pixelOffset < srcPixelArray->length(); pixelOffset++) {
    … …  
    9494    }
    9595
    96     luminancedImage->putImageData(destImageData.get(), intImageRect, IntPoint(0, 0));
     96    luminancedImage->putUnmultipliedImageData(destImageData.get(), intImageRect, IntPoint(0, 0));
    9797
    9898    context->clipToImageBuffer(m_maskRect, luminancedImage.get());
Note: See TracChangeset for help on using the changeset viewer.