#include "config.h"
#include "BitmapImage.h"
#if USE(CG)
#include "FloatConversion.h"
#include "GraphicsContextCG.h"
#include "ImageObserver.h"
#include "SubimageCacheWithTimer.h"
#include <wtf/RetainPtr.h>
#if USE(APPKIT)
#include <ApplicationServices/ApplicationServices.h>
#endif
#if PLATFORM(IOS)
#include <CoreGraphics/CGContextPrivate.h>
#endif
#if PLATFORM(COCOA)
#include "WebCoreSystemInterface.h"
#endif
#if PLATFORM(WIN)
#include <WebKitSystemInterface/WebKitSystemInterface.h>
#endif
namespace WebCore {
bool FrameData::clear(bool clearMetadata)
{
if (clearMetadata)
m_haveMetadata = false;
m_orientation = DefaultImageOrientation;
#if PLATFORM(IOS)
m_frameBytes = 0;
m_subsamplingScale = 1;
m_haveInfo = false;
#endif
if (m_frame) {
#if CACHE_SUBIMAGES
subimageCache().clearImage(m_frame);
#endif
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_repetitionCount(cAnimationNone)
, m_repetitionCountStatus(Unknown)
, m_repetitionsComplete(0)
, m_decodedSize(0)
, m_decodedPropertiesSize(0)
, m_frameCount(1)
, m_isSolidColor(false)
, m_checkedForSolidColor(false)
, m_animationFinished(true)
, m_allDataReceived(true)
, m_haveSize(true)
, m_sizeAvailable(true)
, m_haveFrameCount(true)
{
CGFloat width = CGImageGetWidth(cgImage);
CGFloat height = CGImageGetHeight(cgImage);
m_decodedSize = width * height * 4;
m_size = IntSize(width, height);
m_sizeRespectingOrientation = m_size;
#if PLATFORM(IOS)
m_originalSize = m_size;
m_originalSizeRespectingOrientation = m_size;
#endif
m_frames.grow(1);
m_frames[0].m_frame = CGImageRetain(cgImage);
m_frames[0].m_hasAlpha = true;
m_frames[0].m_haveMetadata = true;
#if PLATFORM(IOS)
m_frames[0].m_subsamplingScale = 1;
#endif
checkForSolidColor();
}
void BitmapImage::checkForSolidColor()
{
m_checkedForSolidColor = true;
if (frameCount() > 1) {
m_isSolidColor = false;
return;
}
#if !PLATFORM(IOS)
CGImageRef image = frameAtIndex(0);
#else
CGImageRef image = nullptr;
if (m_frames.size())
image = m_frames[0].m_frame;
if (!image)
image = frameAtIndex(0);
#endif
if (image && CGImageGetWidth(image) == 1 && CGImageGetHeight(image) == 1) {
unsigned char pixel[4]; RetainPtr<CGContextRef> bitmapContext = adoptCF(CGBitmapContextCreate(pixel, 1, 1, 8, sizeof(pixel), deviceRGBColorSpaceRef(),
kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big));
if (!bitmapContext)
return;
GraphicsContext(bitmapContext.get()).setCompositeOperation(CompositeCopy);
CGRect destinationRect = CGRectMake(0, 0, 1, 1);
CGContextDrawImage(bitmapContext.get(), destinationRect, image);
if (!pixel[3])
m_solidColor = Color(0, 0, 0, 0);
else
m_solidColor = Color(pixel[0] * 255 / pixel[3], pixel[1] * 255 / pixel[3], pixel[2] * 255 / pixel[3], pixel[3]);
m_isSolidColor = true;
}
}
CGImageRef BitmapImage::getCGImageRef()
{
return frameAtIndex(0);
}
CGImageRef BitmapImage::getFirstCGImageRefOfSize(const IntSize& size)
{
size_t count = frameCount();
for (size_t i = 0; i < count; ++i) {
CGImageRef cgImage = frameAtIndex(i);
if (cgImage && IntSize(CGImageGetWidth(cgImage), CGImageGetHeight(cgImage)) == size)
return cgImage;
}
return getCGImageRef();
}
RetainPtr<CFArrayRef> BitmapImage::getCGImageArray()
{
size_t count = frameCount();
if (!count)
return 0;
CFMutableArrayRef array = CFArrayCreateMutable(NULL, count, &kCFTypeArrayCallBacks);
for (size_t i = 0; i < count; ++i) {
if (CGImageRef currFrame = frameAtIndex(i))
CFArrayAppendValue(array, currFrame);
}
return adoptCF(array);
}
void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& destRect, const FloatRect& srcRect, ColorSpace styleColorSpace, CompositeOperator compositeOp, BlendMode blendMode, ImageOrientationDescription description)
{
CGImageRef image;
FloatRect srcRectForCurrentFrame = srcRect;
#if PLATFORM(IOS)
if (m_originalSize != m_size && !m_originalSize.isEmpty())
srcRectForCurrentFrame.scale(m_size.width() / static_cast<float>(m_originalSize.width()), m_size.height() / static_cast<float>(m_originalSize.height()));
startAnimation(DoNotCatchUp);
CGRect transformedDestinationRect = CGRectApplyAffineTransform(destRect, CGContextGetCTM(ctxt->platformContext()));
RetainPtr<CGImageRef> imagePossiblyCopied;
if (CGContextGetType(ctxt->platformContext()) == kCGContextTypePDF)
imagePossiblyCopied = adoptCF(copyUnscaledFrameAtIndex(m_currentFrame));
else
imagePossiblyCopied = frameAtIndex(m_currentFrame, std::min<float>(1.0f, std::max(transformedDestinationRect.size.width / srcRectForCurrentFrame.width(), transformedDestinationRect.size.height / srcRectForCurrentFrame.height())));
image = imagePossiblyCopied.get();
#else
startAnimation();
image = frameAtIndex(m_currentFrame);
#endif
if (!image) return;
if (mayFillWithSolidColor()) {
fillWithSolidColor(ctxt, destRect, solidColor(), styleColorSpace, compositeOp);
return;
}
float scale = 1;
#if PLATFORM(IOS)
scale = m_frames[m_currentFrame].m_subsamplingScale;
#endif
FloatSize selfSize = currentFrameSize();
ImageOrientation orientation;
if (description.respectImageOrientation() == RespectImageOrientation)
orientation = frameOrientationAtIndex(m_currentFrame);
ctxt->drawNativeImage(image, selfSize, styleColorSpace, destRect, srcRectForCurrentFrame, scale, compositeOp, blendMode, orientation);
if (imageObserver())
imageObserver()->didDraw(this);
}
#if PLATFORM(IOS)
PassNativeImagePtr BitmapImage::copyUnscaledFrameAtIndex(size_t index)
{
if (index >= frameCount())
return nullptr;
if (index >= m_frames.size() || !m_frames[index].m_frame)
cacheFrame(index, 1);
if (m_frames[index].m_subsamplingScale == 1 && !m_source.isSubsampled())
return CGImageRetain(m_frames[index].m_frame);
return m_source.createFrameAtIndex(index);
}
#endif
}
#endif // USE(CG)