#ifndef ImageDecoder_h
#define ImageDecoder_h
#include "IntRect.h"
#include "ImageSource.h"
#include "PlatformString.h"
#include "SharedBuffer.h"
#include <wtf/Assertions.h>
#include <wtf/RefPtr.h>
#include <wtf/Vector.h>
#if USE(SKIA)
#include "NativeImageSkia.h"
#include "SkColorPriv.h"
#elif PLATFORM(QT)
#include <QPixmap>
#include <QImage>
#endif
namespace WebCore {
typedef Vector<char> ColorProfile;
class ImageFrame {
public:
enum FrameStatus { FrameEmpty, FramePartial, FrameComplete };
enum FrameDisposalMethod {
DisposeNotSpecified, DisposeKeep, DisposeOverwriteBgcolor, DisposeOverwritePrevious };
#if USE(SKIA) || (PLATFORM(QT) && USE(QT_IMAGE_DECODER))
typedef uint32_t PixelData;
#else
typedef unsigned PixelData;
#endif
ImageFrame();
ImageFrame(const ImageFrame& other) { operator=(other); }
ImageFrame& operator=(const ImageFrame& other);
void clearPixelData();
void zeroFillPixelData();
bool copyBitmapData(const ImageFrame&);
void copyReferenceToBitmapData(const ImageFrame&);
void copyRowNTimes(int startX, int endX, int startY, int endY)
{
ASSERT(startX < width());
ASSERT(endX <= width());
ASSERT(startY < height());
ASSERT(endY <= height());
const int rowBytes = (endX - startX) * sizeof(PixelData);
const PixelData* const startAddr = getAddr(startX, startY);
for (int destY = startY + 1; destY < endY; ++destY)
memcpy(getAddr(startX, destY), startAddr, rowBytes);
}
bool setSize(int newWidth, int newHeight);
NativeImagePtr asNewNativeImage() const;
bool hasAlpha() const;
const IntRect& originalFrameRect() const { return m_originalFrameRect; }
FrameStatus status() const { return m_status; }
unsigned duration() const { return m_duration; }
FrameDisposalMethod disposalMethod() const { return m_disposalMethod; }
bool premultiplyAlpha() const { return m_premultiplyAlpha; }
void setHasAlpha(bool alpha);
void setColorProfile(const ColorProfile&);
void setOriginalFrameRect(const IntRect& r) { m_originalFrameRect = r; }
void setStatus(FrameStatus status);
void setDuration(unsigned duration) { m_duration = duration; }
void setDisposalMethod(FrameDisposalMethod method) { m_disposalMethod = method; }
void setPremultiplyAlpha(bool premultiplyAlpha) { m_premultiplyAlpha = premultiplyAlpha; }
inline void setRGBA(int x, int y, unsigned r, unsigned g, unsigned b, unsigned a)
{
setRGBA(getAddr(x, y), r, g, b, a);
}
inline PixelData* getAddr(int x, int y)
{
#if USE(SKIA)
return m_bitmap.bitmap().getAddr32(x, y);
#elif PLATFORM(QT) && USE(QT_IMAGE_DECODER)
m_image = m_pixmap.toImage();
m_pixmap = QPixmap();
return reinterpret_cast_ptr<QRgb*>(m_image.scanLine(y)) + x;
#else
return m_bytes + (y * width()) + x;
#endif
}
#if PLATFORM(QT) && USE(QT_IMAGE_DECODER)
void setPixmap(const QPixmap& pixmap);
#endif
private:
#if USE(CG)
typedef RetainPtr<CFMutableDataRef> NativeBackingStore;
#else
typedef Vector<PixelData> NativeBackingStore;
#endif
int width() const;
int height() const;
inline void setRGBA(PixelData* dest, unsigned r, unsigned g, unsigned b, unsigned a)
{
if (m_premultiplyAlpha && !a)
*dest = 0;
else {
if (m_premultiplyAlpha && a < 255) {
float alphaPercent = a / 255.0f;
r = static_cast<unsigned>(r * alphaPercent);
g = static_cast<unsigned>(g * alphaPercent);
b = static_cast<unsigned>(b * alphaPercent);
}
#if USE(SKIA)
*dest = SkPackARGB32NoCheck(a, r, g, b);
#else
*dest = (a << 24 | r << 16 | g << 8 | b);
#endif
}
}
#if USE(SKIA)
NativeImageSkia m_bitmap;
#if PLATFORM(CHROMIUM) && OS(DARWIN)
ColorProfile m_colorProfile;
#endif
#elif PLATFORM(QT) && USE(QT_IMAGE_DECODER)
mutable QPixmap m_pixmap;
mutable QImage m_image;
bool m_hasAlpha;
IntSize m_size;
#else
NativeBackingStore m_backingStore;
PixelData* m_bytes; IntSize m_size;
bool m_hasAlpha;
ColorProfile m_colorProfile;
#endif
IntRect m_originalFrameRect; FrameStatus m_status;
unsigned m_duration;
FrameDisposalMethod m_disposalMethod;
bool m_premultiplyAlpha;
};
class ImageDecoder {
WTF_MAKE_NONCOPYABLE(ImageDecoder); WTF_MAKE_FAST_ALLOCATED;
public:
ImageDecoder(ImageSource::AlphaOption alphaOption, ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
: m_scaled(false)
, m_premultiplyAlpha(alphaOption == ImageSource::AlphaPremultiplied)
, m_ignoreGammaAndColorProfile(gammaAndColorProfileOption == ImageSource::GammaAndColorProfileIgnored)
, m_sizeAvailable(false)
, m_maxNumPixels(-1)
, m_isAllDataReceived(false)
, m_failed(false) { }
virtual ~ImageDecoder() { }
static ImageDecoder* create(const SharedBuffer& data, ImageSource::AlphaOption, ImageSource::GammaAndColorProfileOption);
virtual String filenameExtension() const = 0;
bool isAllDataReceived() const { return m_isAllDataReceived; }
virtual void setData(SharedBuffer* data, bool allDataReceived)
{
if (m_failed)
return;
m_data = data;
m_isAllDataReceived = allDataReceived;
}
virtual bool isSizeAvailable()
{
return !m_failed && m_sizeAvailable;
}
virtual IntSize size() const { return m_size; }
IntSize scaledSize() const
{
return m_scaled ? IntSize(m_scaledColumns.size(), m_scaledRows.size()) : size();
}
virtual IntSize frameSizeAtIndex(size_t) const
{
return size();
}
virtual bool setSize(unsigned width, unsigned height)
{
if (isOverSize(width, height))
return setFailed();
m_size = IntSize(width, height);
m_sizeAvailable = true;
return true;
}
virtual size_t frameCount() { return 1; }
virtual int repetitionCount() const { return cAnimationNone; }
virtual ImageFrame* frameBufferAtIndex(size_t) = 0;
void setIgnoreGammaAndColorProfile(bool flag) { m_ignoreGammaAndColorProfile = flag; }
bool ignoresGammaAndColorProfile() const { return m_ignoreGammaAndColorProfile; }
enum { iccColorProfileHeaderLength = 128 };
static bool rgbColorProfile(const char* profileData, unsigned profileLength)
{
ASSERT(profileLength >= iccColorProfileHeaderLength);
return !memcmp(&profileData[16], "RGB ", 4);
}
static bool inputDeviceColorProfile(const char* profileData, unsigned profileLength)
{
ASSERT(profileLength >= iccColorProfileHeaderLength);
return !memcmp(&profileData[12], "mntr", 4) || !memcmp(&profileData[12], "scnr", 4);
}
virtual bool setFailed()
{
m_failed = true;
return false;
}
bool failed() const { return m_failed; }
virtual void clearFrameBufferCache(size_t) { }
#if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
void setMaxNumPixels(int m) { m_maxNumPixels = m; }
#endif
protected:
void prepareScaleDataIfNecessary();
int upperBoundScaledX(int origX, int searchStart = 0);
int lowerBoundScaledX(int origX, int searchStart = 0);
int upperBoundScaledY(int origY, int searchStart = 0);
int lowerBoundScaledY(int origY, int searchStart = 0);
int scaledY(int origY, int searchStart = 0);
RefPtr<SharedBuffer> m_data; Vector<ImageFrame> m_frameBufferCache;
ColorProfile m_colorProfile;
bool m_scaled;
Vector<int> m_scaledColumns;
Vector<int> m_scaledRows;
bool m_premultiplyAlpha;
bool m_ignoreGammaAndColorProfile;
private:
static bool isOverSize(unsigned width, unsigned height)
{
unsigned long long total_size = static_cast<unsigned long long>(width)
* static_cast<unsigned long long>(height);
return total_size > ((1 << 29) - 1);
}
IntSize m_size;
bool m_sizeAvailable;
int m_maxNumPixels;
bool m_isAllDataReceived;
bool m_failed;
};
}
#endif