WebCore/platform/graphics/cg/ImageBufferCG.cpp

   1 /*
   2  * Copyright (C) 2006 Nikolas Zimmermann <zimmermann@kde.org>
   3  * Copyright (C) 2008 Apple, Inc
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "config.h"
  28 #include "ImageBuffer.h"
  29
  30 #include "GraphicsContext.h"
  31 #include "ImageData.h"
  32
  33 #include <ApplicationServices/ApplicationServices.h>
  34 #include <wtf/Assertions.h>
  35
  36 using namespace std;
  37
  38 namespace WebCore {
  39
  40 auto_ptr<ImageBuffer> ImageBuffer::create(const IntSize& size, bool grayScale)
  41 {
  42     if (size.width() < 0 || size.height() < 0)
  43         return auto_ptr<ImageBuffer>();
  44     unsigned int bytesPerRow = size.width();
  45     if (!grayScale) {
  46         // Protect against overflow
  47         if (bytesPerRow > 0x3FFFFFFF)
  48             return auto_ptr<ImageBuffer>();
  49         bytesPerRow *= 4;
  50     }
  51
  52     void* imageBuffer = fastCalloc(size.height(), bytesPerRow);
  53     if (!imageBuffer)
  54         return auto_ptr<ImageBuffer>();
  55
  56     CGColorSpaceRef colorSpace = grayScale ? CGColorSpaceCreateDeviceGray() : CGColorSpaceCreateDeviceRGB();
  57     CGContextRef cgContext = CGBitmapContextCreate(imageBuffer, size.width(), size.height(), 8, bytesPerRow,
  58         colorSpace, grayScale ? kCGImageAlphaNone : kCGImageAlphaPremultipliedLast);
  59     CGColorSpaceRelease(colorSpace);
  60     if (!cgContext) {
  61         fastFree(imageBuffer);
  62         return auto_ptr<ImageBuffer>();
  63     }
  64
  65     auto_ptr<GraphicsContext> context(new GraphicsContext(cgContext));
  66     CGContextRelease(cgContext);
  67
  68     return auto_ptr<ImageBuffer>(new ImageBuffer(imageBuffer, size, context));
  69 }
  70
  71
  72 ImageBuffer::ImageBuffer(void* imageData, const IntSize& size, auto_ptr<GraphicsContext> context)
  73     : m_data(imageData)
  74     , m_size(size)
  75     , m_context(context.release())
  76     , m_cgImage(0)
  77 {
  78     ASSERT((reinterpret_cast<size_t>(imageData) & 2) == 0);
  79 }
  80
  81 ImageBuffer::~ImageBuffer()
  82 {
  83     fastFree(m_data);
  84     CGImageRelease(m_cgImage);
  85 }
  86
  87 GraphicsContext* ImageBuffer::context() const
  88 {
  89     return m_context.get();
  90 }
  91
  92 CGImageRef ImageBuffer::cgImage() const
  93 {
  94     // It's assumed that if cgImage() is called, the actual rendering to the
  95     // contained GraphicsContext must be done, as we create the CGImageRef here.
  96     if (!m_cgImage) {
  97         ASSERT(context());
  98         m_cgImage = CGBitmapContextCreateImage(context()->platformContext());
  99     }
 100
 101     return m_cgImage;
 102 }
 103
 104 PassRefPtr<ImageData> ImageBuffer::getImageData(const IntRect& rect) const
 105 {
 106     if (!m_data)
 107         return 0;
 108
 109     PassRefPtr<ImageData> result = ImageData::create(rect.width(), rect.height());
 110     unsigned char* data = result->data()->data().data();
 111
 112     if (rect.x() < 0 || rect.y() < 0 || (rect.x() + rect.width()) > m_size.width() || (rect.y() + rect.height()) > m_size.height())
 113         memset(data, 0, result->data()->length());
 114
 115     int originx = rect.x();
 116     int destx = 0;
 117     if (originx < 0) {
 118         destx = -originx;
 119         originx = 0;
 120     }
 121     int endx = rect.x() + rect.width();
 122     if (endx > m_size.width())
 123         endx = m_size.width();
 124     int numColumns = endx - originx;
 125
 126     int originy = rect.y();
 127     int desty = 0;
 128     if (originy < 0) {
 129         desty = -originy;
 130         originy = 0;
 131     }
 132     int endy = rect.y() + rect.height();
 133     if (endy > m_size.height())
 134         endy = m_size.height();
 135     int numRows = endy - originy;
 136
 137     unsigned srcBytesPerRow = 4 * m_size.width();
 138     unsigned destBytesPerRow = 4 * rect.width();
 139
 140     // m_size.height() - originy to handle the accursed flipped y axis in CG backing store
 141     unsigned char* srcRows = reinterpret_cast<unsigned char*>(m_data) + (m_size.height() - originy - 1) * srcBytesPerRow + originx * 4;
 142     unsigned char* destRows = data + desty * destBytesPerRow + destx * 4;
 143     for (int y = 0; y < numRows; ++y) {
 144         for (int x = 0; x < numColumns; x++) {
 145             if (unsigned char alpha = srcRows[3]) {
 146                 destRows[0] = (srcRows[0] * 255) / alpha;
 147                 destRows[1] = (srcRows[1] * 255) / alpha;
 148                 destRows[2] = (srcRows[2] * 255) / alpha;
 149                 destRows[3] = alpha;
 150             } else {
 151                 reinterpret_cast<uint32_t*>(destRows)[0] = reinterpret_cast<uint32_t*>(srcRows)[0];
 152             }
 153             destRows += 4;
 154         }
 155         srcRows -= srcBytesPerRow;
 156     }
 157     return result;
 158 }
 159
 160 void ImageBuffer::putImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
 161 {
 162     ASSERT(sourceRect.width() > 0);
 163     ASSERT(sourceRect.height() > 0);
 164
 165     int originx = sourceRect.x();
 166     int destx = destPoint.x() + sourceRect.x();
 167     ASSERT(destx >= 0);
 168     ASSERT(destx < m_size.width());
 169     ASSERT(originx >= 0);
 170     ASSERT(originx <= sourceRect.right());
 171
 172     int endx = destPoint.x() + sourceRect.right();
 173     ASSERT(endx <= m_size.width());
 174
 175     int numColumns = endx - destx;
 176
 177     int originy = sourceRect.y();
 178     int desty = destPoint.y() + sourceRect.y();
 179     ASSERT(desty >= 0);
 180     ASSERT(desty < m_size.height());
 181     ASSERT(originy >= 0);
 182     ASSERT(originy <= sourceRect.bottom());
 183
 184     int endy = destPoint.y() + sourceRect.bottom();
 185     ASSERT(endx <= m_size.height());
 186     int numRows = endy - desty;
 187
 188     unsigned srcBytesPerRow = 4 * source->width();
 189     unsigned destBytesPerRow = 4 * m_size.width();
 190
 191     unsigned char* srcRows = source->data()->data().data() + originy * srcBytesPerRow + originx * 4;
 192
 193     // -desty to handle the accursed flipped y axis
 194     unsigned char* destRows = reinterpret_cast<unsigned char*>(m_data) + (m_size.height() - desty - 1) * destBytesPerRow + destx * 4;
 195     for (int y = 0; y < numRows; ++y) {
 196         for (int x = 0; x < numColumns; x++) {
 197             unsigned char alpha = srcRows[x * 4 + 3];
 198             if (alpha != 255) {
 199                 destRows[x * 4 + 0] = (srcRows[0] * alpha) / 255;
 200                 destRows[x * 4 + 1] = (srcRows[1] * alpha) / 255;
 201                 destRows[x * 4 + 2] = (srcRows[2] * alpha) / 255;
 202                 destRows[x * 4 + 3] = alpha;
 203             } else {
 204                 reinterpret_cast<uint32_t*>(destRows + x * 4)[0] = reinterpret_cast<uint32_t*>(srcRows + x * 4)[0];
 205             }
 206         }
 207         destRows -= destBytesPerRow;
 208         srcRows += srcBytesPerRow;
 209     }
 210 }
 211
 212 }