#include "config.h"
#include "BitmapImage.h"
#if PLATFORM(CG)
#include "AffineTransform.h"
#include "FloatConversion.h"
#include "FloatRect.h"
#include "GraphicsContext.h"
#include "GraphicsContextPlatformPrivateCG.h"
#include "ImageObserver.h"
#if ENABLE(RESPECT_EXIF_ORIENTATION)
#include "ImageSourceCG.h"
#endif
#include "PDFDocumentImage.h"
#include "PlatformString.h"
#include <CoreGraphics/CoreGraphics.h>
#if PLATFORM(MAC) || PLATFORM(CHROMIUM)
#include "WebCoreSystemInterface.h"
#endif
#if PLATFORM(WIN)
#include <WebKitSystemInterface/WebKitSystemInterface.h>
#endif
namespace WebCore {
bool FrameData::clear(bool clearMetadata)
{
if (clearMetadata)
m_haveMetadata = false;
#if ENABLE(RESPECT_EXIF_ORIENTATION)
m_orientation = 0;
#endif
m_bytes = 0;
m_scale = 1.0f;
m_haveInfo = false;
if (m_frame) {
CGImageRelease(m_frame);
m_frame = 0;
return true;
}
return false;
}
BitmapImage::BitmapImage(CGImageRef cgImage, ImageObserver* observer)
: Image(observer)
, m_currentFrame(0)
, m_frames(0)
, m_frameTimer(0)
, m_repetitionCount(cAnimationNone)
, m_repetitionCountStatus(Unknown)
, m_repetitionsComplete(0)
, m_isSolidColor(false)
, m_checkedForSolidColor(false)
, m_animationFinished(true)
, m_allDataReceived(true)
, m_haveSize(true)
, m_sizeAvailable(true)
, m_decodedSize(0)
, m_haveFrameCount(true)
, m_frameCount(1)
{
initPlatformData();
CGFloat width = CGImageGetWidth(cgImage);
CGFloat height = CGImageGetHeight(cgImage);
m_decodedSize = width * height * 4;
m_size = IntSize(width, height);
m_frames.grow(1);
m_frames[0].m_frame = cgImage;
m_frames[0].m_hasAlpha = true;
m_frames[0].m_haveMetadata = true;
m_frames[0].m_scale = 1.0f;
checkForSolidColor();
}
void BitmapImage::checkForSolidColor()
{
m_checkedForSolidColor = true;
if (frameCount() > 1) {
m_isSolidColor = false;
return;
}
if (!m_frames.size())
return;
CGImageRef image = m_frames[0].m_frame;
if (image && CGImageGetWidth(image) == 1 && CGImageGetHeight(image) == 1) {
unsigned char pixel[4] = {0, 0, 0, 0}; static CGColorSpaceRef space = CGColorSpaceCreateDeviceRGB();
RetainPtr<CGContextRef> bmap(AdoptCF, CGBitmapContextCreate(pixel, 1, 1, 8, sizeof(pixel), space,
kCGImageAlphaPremultipliedLast));
if (!bmap)
return;
GraphicsContext(bmap.get()).setCompositeOperation(CompositeCopy);
CGRect dst = { {0, 0}, {1, 1} };
CGContextDrawImage(bmap.get(), dst, image);
if (pixel[3] == 0)
m_solidColor = Color(0, 0, 0, 0);
else
m_solidColor = Color((int)pixel[0], (int)pixel[1], (int)pixel[2], (int)pixel[3]);
m_isSolidColor = true;
}
}
static RetainPtr<CGImageRef> imageWithColorSpace(CGImageRef originalImage, ColorSpace colorSpace)
{
CGColorSpaceRef originalColorSpace = CGImageGetColorSpace(originalImage);
if (!originalColorSpace || !CFEqual(originalColorSpace, deviceRGBColorSpaceRef()))
return originalImage;
switch (colorSpace) {
case DeviceColorSpace:
return originalImage;
case sRGBColorSpace:
return RetainPtr<CGImageRef>(AdoptCF, CGImageCreateCopyWithColorSpace(originalImage,
sRGBColorSpaceRef()));
}
ASSERT_NOT_REACHED();
return originalImage;
}
CGImageRef BitmapImage::getCGImageRef()
{
return frameAtIndex(0);
}
void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& destRect, const FloatRect& srcRect, ColorSpace styleColorSpace, CompositeOperator compositeOp)
{
startAnimation(false);
CGRect transformedDstRect = CGRectApplyAffineTransform(destRect, CGContextGetCTM(ctxt->platformContext()));
RetainPtr<CGImageRef> image;
if (CGContextGetType(ctxt->platformContext()) == kCGContextTypePDF)
image.adoptCF(copyUnscaledFrameAtIndex(m_currentFrame));
else
image = frameAtIndex(m_currentFrame, std::min(1.0f, std::max(transformedDstRect.size.width / srcRect.width(),
transformedDstRect.size.height / srcRect.height())));
if (!image) return;
if (mayFillWithSolidColor()) {
fillWithSolidColor(ctxt, destRect, solidColor(), styleColorSpace, compositeOp);
return;
}
float currHeight = CGImageGetHeight(image.get());
#if ENABLE(RESPECT_EXIF_ORIENTATION)
if (orientationRequiresWidthAndHeightSwapped(frameOrientationAtIndex(m_currentFrame)))
currHeight = CGImageGetWidth(image.get());
#endif
currHeight /= m_frames[m_currentFrame].m_scale;
if (currHeight <= srcRect.y())
return;
CGContextRef context = ctxt->platformContext();
ctxt->save();
CGContextSetShouldAntialias(context, false);
bool shouldUseSubimage = false;
FloatRect adjustedDestRect = destRect;
FloatSize selfSize = currentFrameSize();
if (srcRect.size() != selfSize) {
CGInterpolationQuality interpolationQuality = CGContextGetInterpolationQuality(context);
shouldUseSubimage = (interpolationQuality == kCGInterpolationHigh || interpolationQuality == kCGInterpolationDefault) && srcRect.size() != destRect.size();
float xScale = srcRect.width() / destRect.width();
float yScale = srcRect.height() / destRect.height();
if (shouldUseSubimage) {
FloatRect subimageRect = srcRect;
float leftPadding = srcRect.x() - floorf(srcRect.x());
float topPadding = srcRect.y() - floorf(srcRect.y());
subimageRect.move(-leftPadding, -topPadding);
adjustedDestRect.move(-leftPadding / xScale, -topPadding / yScale);
subimageRect.setWidth(ceilf(subimageRect.width() + leftPadding));
adjustedDestRect.setWidth(subimageRect.width() / xScale);
subimageRect.setHeight(ceilf(subimageRect.height() + topPadding));
adjustedDestRect.setHeight(subimageRect.height() / yScale);
image.adoptCF(CGImageCreateWithImageInRect(image.get(), subimageRect));
if (currHeight < srcRect.bottom()) {
ASSERT(CGImageGetHeight(image.get()) == currHeight - CGRectIntegral(srcRect).origin.y);
adjustedDestRect.setHeight(CGImageGetHeight(image.get()) / yScale);
}
} else {
adjustedDestRect.setLocation(FloatPoint(destRect.x() - srcRect.x() / xScale, destRect.y() - srcRect.y() / yScale));
adjustedDestRect.setSize(FloatSize(selfSize.width() / xScale, selfSize.height() / yScale));
}
CGContextClipToRect(context, destRect);
}
if (!shouldUseSubimage && currHeight < selfSize.height())
adjustedDestRect.setHeight(adjustedDestRect.height() * currHeight / selfSize.height());
adjustedDestRect = ctxt->roundToDevicePixels(adjustedDestRect);
#if ENABLE(RESPECT_EXIF_ORIENTATION)
float w = adjustedDestRect.width();
float h = adjustedDestRect.height();
CGAffineTransform transform;
switch (frameOrientationAtIndex(m_currentFrame)) {
case BitmapImage::ImageEXIFOrientationBottomRight:
transform = CGAffineTransformMake(-1, 0, 0, -1, w, h);
break;
case BitmapImage::ImageEXIFOrientationLeftBottom:
transform = CGAffineTransformMake( 0, 1, -1, 0, w, 0);
break;
case BitmapImage::ImageEXIFOrientationRightTop:
transform = CGAffineTransformMake( 0, -1, 1, 0, 0, h);
break;
case BitmapImage::ImageEXIFOrientationTopRight:
transform = CGAffineTransformMake(-1, 0, 0, 1, w, 0);
break;
case BitmapImage::ImageEXIFOrientationBottomLeft:
transform = CGAffineTransformMake( 1, 0, 0, -1, 0, h);
break;
case BitmapImage::ImageEXIFOrientationLeftTop:
transform = CGAffineTransformMake( 0, -1, -1, 0, w, h);
break;
case BitmapImage::ImageEXIFOrientationRightBottom:
transform = CGAffineTransformMake( 0, 1, 1, 0, 0, 0);
break;
default:
transform = CGAffineTransformIdentity;
break;
}
CGContextTranslateCTM(context, adjustedDestRect.x(), adjustedDestRect.bottom());
#endif
ctxt->setCompositeOperation(compositeOp);
CGContextScaleCTM(context, 1, -1);
#if ENABLE(RESPECT_EXIF_ORIENTATION)
CGContextConcatCTM(context, transform);
if (orientationRequiresWidthAndHeightSwapped(frameOrientationAtIndex(m_currentFrame))) {
adjustedDestRect = FloatRect(adjustedDestRect.x(), adjustedDestRect.y(), adjustedDestRect.height(), adjustedDestRect.width());
}
adjustedDestRect.setLocation(FloatPoint());
#else
adjustedDestRect.setY(-adjustedDestRect.bottom());
#endif
image = imageWithColorSpace(image.get(), styleColorSpace);
CGContextDrawImage(context, adjustedDestRect, image.get());
ctxt->restore();
if (imageObserver())
imageObserver()->didDraw(this);
}
static void drawPatternCallback(void* info, CGContextRef context)
{
CGImageRef image = (CGImageRef)info;
CGFloat h = CGImageGetHeight(image);
CGContextScaleCTM (context, 1, -1);
CGContextTranslateCTM (context, 0, -h);
CGContextDrawImage(context, GraphicsContext(context).roundToDevicePixels(FloatRect(0, 0, CGImageGetWidth(image), h)), image);
}
void Image::drawPattern(GraphicsContext* ctxt, const FloatRect& tileRect, const AffineTransform& patternTransform,
const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect)
{
if (!nativeImageForCurrentFrame())
return;
ASSERT(patternTransform.isInvertible());
if (!patternTransform.isInvertible())
return;
CGContextRef context = ctxt->platformContext();
ctxt->save();
CGContextClipToRect(context, destRect);
ctxt->setCompositeOperation(op);
CGContextTranslateCTM(context, destRect.x(), destRect.y() + destRect.height());
CGContextScaleCTM(context, 1, -1);
float scaledTileHeight = tileRect.height() * narrowPrecisionToFloat(patternTransform.d());
float adjustedX = phase.x() - destRect.x() + tileRect.x() * narrowPrecisionToFloat(patternTransform.a()); float adjustedY = destRect.height() - (phase.y() - destRect.y() + tileRect.y() * narrowPrecisionToFloat(patternTransform.d()) + scaledTileHeight);
CGImageRef tileImage = nativeImageForCurrentFrame();
float h = CGImageGetHeight(tileImage);
RetainPtr<CGImageRef> subImage;
if (tileRect.size() == size())
subImage = tileImage;
else {
ASSERT(h == height());
subImage.adoptCF(CGImageCreateWithImageInRect(tileImage, tileRect));
}
subImage = imageWithColorSpace(subImage.get(), styleColorSpace);
#ifndef BUILDING_ON_TIGER
float scaledTileWidth = tileRect.width() * narrowPrecisionToFloat(patternTransform.a());
float w = CGImageGetWidth(tileImage);
#ifdef BUILDING_ON_LEOPARD
if (w == size().width() && h == size().height() && scaledTileWidth == tileRect.width() && scaledTileHeight == tileRect.height())
#else
if (w == size().width() && h == size().height())
#endif
CGContextDrawTiledImage(context, FloatRect(adjustedX, adjustedY, scaledTileWidth, scaledTileHeight), subImage.get());
else {
#endif
static const CGPatternCallbacks patternCallbacks = { 0, drawPatternCallback, NULL };
CGAffineTransform matrix = CGAffineTransformMake(narrowPrecisionToCGFloat(patternTransform.a()), 0, 0, narrowPrecisionToCGFloat(patternTransform.d()), adjustedX, adjustedY);
matrix = CGAffineTransformConcat(matrix, CGContextGetCTM(context));
matrix = CGAffineTransformTranslate(matrix, 0, size().height() - h);
matrix = CGAffineTransformScale(matrix, 1, -1);
matrix = CGAffineTransformTranslate(matrix, 0, -h);
RetainPtr<CGPatternRef> pattern(AdoptCF, CGPatternCreate(subImage.get(), CGRectMake(0, 0, tileRect.width(), tileRect.height()),
matrix, tileRect.width(), tileRect.height(),
kCGPatternTilingConstantSpacing, true, &patternCallbacks));
if (!pattern) {
ctxt->restore();
return;
}
RetainPtr<CGColorSpaceRef> patternSpace(AdoptCF, CGColorSpaceCreatePattern(0));
CGFloat alpha = 1;
RetainPtr<CGColorRef> color(AdoptCF, CGColorCreateWithPattern(patternSpace.get(), pattern.get(), &alpha));
CGContextSetFillColorSpace(context, patternSpace.get());
wkSetPatternBaseCTM(context, CGAffineTransformIdentity);
CGContextSetPatternPhase(context, CGSizeZero);
CGContextSetFillColorWithColor(context, color.get());
CGContextFillRect(context, CGContextGetClipBoundingBox(context));
#ifndef BUILDING_ON_TIGER
}
#endif
ctxt->restore();
if (imageObserver())
imageObserver()->didDraw(this);
}
NativeImagePtr BitmapImage::copyUnscaledFrameAtIndex(size_t index)
{
if (index >= frameCount())
return 0;
if (index >= m_frames.size() || !m_frames[index].m_frame)
cacheFrame(index, 1);
if (m_frames[index].m_scale == 1 && !m_source.isSubsampled())
return CGImageRetain(m_frames[index].m_frame);
float ignoredScale;
ssize_t ignoredBytes;
return m_source.createFrameAtIndex(index, std::numeric_limits<float>::infinity(), &ignoredScale, &ignoredBytes);
}
}
#endif // PLATFORM(CG)