#ifndef ImageBuffer_h
#define ImageBuffer_h
#include "AffineTransform.h"
#include "ColorSpace.h"
#include "GraphicsTypes.h"
#include "GraphicsTypes3D.h"
#include "IntSize.h"
#include "ImageBufferData.h"
#include "PlatformLayer.h"
#include <runtime/Uint8ClampedArray.h>
#include <wtf/Forward.h>
#include <wtf/OwnPtr.h>
#include <wtf/PassRefPtr.h>
#include <wtf/Vector.h>
namespace WebCore {
class FloatRect;
class GraphicsContext;
class GraphicsContext3D;
class Image;
class ImageData;
class IntPoint;
class IntRect;
enum Multiply {
Premultiplied,
Unmultiplied
};
enum RenderingMode {
Unaccelerated,
UnacceleratedNonPlatformBuffer, Accelerated
};
enum BackingStoreCopy {
CopyBackingStore, DontCopyBackingStore };
enum ScaleBehavior {
Scaled,
Unscaled
};
class ImageBuffer {
WTF_MAKE_NONCOPYABLE(ImageBuffer); WTF_MAKE_FAST_ALLOCATED;
public:
static std::unique_ptr<ImageBuffer> create(const FloatSize& size, float resolutionScale = 1, ColorSpace colorSpace = ColorSpaceDeviceRGB, RenderingMode renderingMode = Unaccelerated)
{
bool success = false;
std::unique_ptr<ImageBuffer> buffer(new ImageBuffer(size, resolutionScale, colorSpace, renderingMode, success));
if (!success)
return nullptr;
return buffer;
}
static std::unique_ptr<ImageBuffer> createCompatibleBuffer(const FloatSize&, float resolutionScale, ColorSpace, const GraphicsContext*, bool hasAlpha);
~ImageBuffer();
const IntSize& internalSize() const { return m_size; }
const IntSize& logicalSize() const { return m_logicalSize; }
GraphicsContext* context() const;
PassRefPtr<Image> copyImage(BackingStoreCopy = CopyBackingStore, ScaleBehavior = Scaled) const;
static BackingStoreCopy fastCopyImageMode();
enum CoordinateSystem { LogicalCoordinateSystem, BackingStoreCoordinateSystem };
PassRefPtr<Uint8ClampedArray> getUnmultipliedImageData(const IntRect&, CoordinateSystem = LogicalCoordinateSystem) const;
PassRefPtr<Uint8ClampedArray> getPremultipliedImageData(const IntRect&, CoordinateSystem = LogicalCoordinateSystem) const;
void putByteArray(Multiply multiplied, Uint8ClampedArray*, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint, CoordinateSystem = LogicalCoordinateSystem);
void convertToLuminanceMask();
String toDataURL(const String& mimeType, const double* quality = 0, CoordinateSystem = LogicalCoordinateSystem) const;
#if !USE(CG)
AffineTransform baseTransform() const { return AffineTransform(); }
void transformColorSpace(ColorSpace srcColorSpace, ColorSpace dstColorSpace);
void platformTransformColorSpace(const Vector<int>&);
#else
AffineTransform baseTransform() const { return AffineTransform(1, 0, 0, -1, 0, m_data.m_backingStoreSize.height()); }
#endif
PlatformLayer* platformLayer() const;
bool copyToPlatformTexture(GraphicsContext3D&, Platform3DObject, GC3Denum, bool, bool);
FloatSize spaceSize() const { return m_space; }
void setSpaceSize(const FloatSize& space)
{
m_space = space;
}
private:
#if USE(CG)
RetainPtr<CGImageRef> copyNativeImage(BackingStoreCopy = CopyBackingStore) const;
void flushContext() const;
#endif
void clip(GraphicsContext*, const FloatRect&) const;
void draw(GraphicsContext*, ColorSpace, const FloatRect& destRect, const FloatRect& srcRect = FloatRect(0, 0, -1, -1), CompositeOperator = CompositeSourceOver, BlendMode = BlendModeNormal, bool useLowQualityScale = false);
void drawPattern(GraphicsContext*, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator, const FloatRect& destRect, BlendMode = BlendModeNormal);
inline void genericConvertToLuminanceMask();
friend class GraphicsContext;
friend class GeneratedImage;
friend class CrossfadeGeneratedImage;
friend class GradientImage;
private:
ImageBufferData m_data;
IntSize m_size;
IntSize m_logicalSize;
float m_resolutionScale;
OwnPtr<GraphicsContext> m_context;
FloatSize m_space;
ImageBuffer(const FloatSize&, float resolutionScale, ColorSpace, RenderingMode, bool& success);
};
#if USE(CG)
String ImageDataToDataURL(const ImageData&, const String& mimeType, const double* quality);
#endif
}
#endif // ImageBuffer_h