[GTK] [TextureMapper] Weird brightness with some videos with acceletared compositing
[WebKit.git] / Source / WebCore / platform / graphics / texmap / TextureMapper.h
1 /*
2  Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
3
4  This library is free software; you can redistribute it and/or
5  modify it under the terms of the GNU Library General Public
6  License as published by the Free Software Foundation; either
7  version 2 of the License, or (at your option) any later version.
8
9  This library is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  Library General Public License for more details.
13
14  You should have received a copy of the GNU Library General Public License
15  along with this library; see the file COPYING.LIB.  If not, write to
16  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  Boston, MA 02110-1301, USA.
18  */
19
20 #ifndef TextureMapper_h
21 #define TextureMapper_h
22
23 #if USE(TEXTURE_MAPPER)
24
25 #if (PLATFORM(GTK) || PLATFORM(EFL)) && USE(OPENGL_ES_2)
26 #define TEXMAP_OPENGL_ES_2
27 #endif
28
29 #include "GraphicsContext.h"
30 #include "IntRect.h"
31 #include "IntSize.h"
32 #include "TransformationMatrix.h"
33
34 /*
35     TextureMapper is a mechanism that enables hardware acceleration of CSS animations (accelerated compositing) without
36     a need for a platform specific scene-graph library like CoreAnimations or QGraphicsView.
37 */
38
39 namespace WebCore {
40
41 class BitmapTexturePool;
42 class GraphicsLayer;
43 class TextureMapper;
44 class FilterOperations;
45
46 // A 2D texture that can be the target of software or GL rendering.
47 class BitmapTexture : public RefCounted<BitmapTexture> {
48 public:
49     enum Flag {
50         NoFlag = 0,
51         SupportsAlpha = 0x01
52     };
53
54     enum UpdateContentsFlag {
55         UpdateCanModifyOriginalImageData,
56         UpdateCannotModifyOriginalImageData
57     };
58
59     typedef unsigned Flags;
60
61     BitmapTexture()
62         : m_flags(0)
63     {
64     }
65
66     virtual ~BitmapTexture() { }
67     virtual bool isBackedByOpenGL() const { return false; }
68
69     virtual IntSize size() const = 0;
70     virtual void updateContents(Image*, const IntRect&, const IntPoint& offset, UpdateContentsFlag) = 0;
71     virtual void updateContents(TextureMapper*, GraphicsLayer*, const IntRect& target, const IntPoint& offset, UpdateContentsFlag);
72     virtual void updateContents(const void*, const IntRect& target, const IntPoint& offset, int bytesPerLine, UpdateContentsFlag) = 0;
73     virtual bool isValid() const = 0;
74     inline Flags flags() const { return m_flags; }
75
76     virtual int bpp() const { return 32; }
77     virtual bool canReuseWith(const IntSize& /* contentsSize */, Flags = 0) { return false; }
78     void reset(const IntSize& size, Flags flags = 0)
79     {
80         m_flags = flags;
81         m_contentSize = size;
82         didReset();
83     }
84     virtual void didReset() { }
85
86     inline IntSize contentSize() const { return m_contentSize; }
87     inline int numberOfBytes() const { return size().width() * size().height() * bpp() >> 3; }
88     inline bool isOpaque() const { return !(m_flags & SupportsAlpha); }
89
90 #if ENABLE(CSS_FILTERS)
91     virtual PassRefPtr<BitmapTexture> applyFilters(TextureMapper*, const FilterOperations&) { return this; }
92 #endif
93
94 protected:
95     IntSize m_contentSize;
96
97 private:
98     Flags m_flags;
99 };
100
101 // A "context" class used to encapsulate accelerated texture mapping functions: i.e. drawing a texture
102 // onto the screen or into another texture with a specified transform, opacity and mask.
103 class TextureMapper {
104     WTF_MAKE_FAST_ALLOCATED;
105     friend class BitmapTexture;
106 public:
107     enum AccelerationMode { SoftwareMode, OpenGLMode };
108     enum PaintFlag {
109         PaintingMirrored = 1 << 0,
110     };
111
112     enum WrapMode {
113         StretchWrap,
114         RepeatWrap
115     };
116
117     typedef unsigned PaintFlags;
118
119     static PassOwnPtr<TextureMapper> create(AccelerationMode newMode = SoftwareMode);
120     virtual ~TextureMapper();
121
122     enum ExposedEdges {
123         NoEdges = 0,
124         LeftEdge = 1 << 0,
125         RightEdge = 1 << 1,
126         TopEdge = 1 << 2,
127         BottomEdge = 1 << 3,
128         AllEdges = LeftEdge | RightEdge | TopEdge | BottomEdge,
129     };
130
131     virtual void drawBorder(const Color&, float borderWidth, const FloatRect&, const TransformationMatrix&) = 0;
132     virtual void drawNumber(int number, const Color&, const FloatPoint&, const TransformationMatrix&) = 0;
133
134     virtual void drawTexture(const BitmapTexture&, const FloatRect& target, const TransformationMatrix& modelViewMatrix = TransformationMatrix(), float opacity = 1.0f, unsigned exposedEdges = AllEdges) = 0;
135     virtual void drawSolidColor(const FloatRect&, const TransformationMatrix&, const Color&) = 0;
136
137     // makes a surface the target for the following drawTexture calls.
138     virtual void bindSurface(BitmapTexture* surface) = 0;
139     void setGraphicsContext(GraphicsContext* context) { m_context = context; }
140     GraphicsContext* graphicsContext() { return m_context; }
141     virtual void beginClip(const TransformationMatrix&, const FloatRect&) = 0;
142     virtual void endClip() = 0;
143     virtual IntRect clipBounds() = 0;
144     virtual PassRefPtr<BitmapTexture> createTexture() = 0;
145
146     void setImageInterpolationQuality(InterpolationQuality quality) { m_interpolationQuality = quality; }
147     void setTextDrawingMode(TextDrawingModeFlags mode) { m_textDrawingMode = mode; }
148
149     InterpolationQuality imageInterpolationQuality() const { return m_interpolationQuality; }
150     TextDrawingModeFlags textDrawingMode() const { return m_textDrawingMode; }
151     AccelerationMode accelerationMode() const { return m_accelerationMode; }
152
153     virtual void beginPainting(PaintFlags = 0) { }
154     virtual void endPainting() { }
155
156     void setMaskMode(bool m) { m_isMaskMode = m; }
157
158     virtual IntSize maxTextureSize() const = 0;
159
160     virtual PassRefPtr<BitmapTexture> acquireTextureFromPool(const IntSize&, const BitmapTexture::Flags = BitmapTexture::SupportsAlpha);
161
162     void setPatternTransform(const TransformationMatrix& p) { m_patternTransform = p; }
163     void setWrapMode(WrapMode m) { m_wrapMode = m; }
164
165 protected:
166     explicit TextureMapper(AccelerationMode);
167
168     GraphicsContext* m_context;
169
170     bool isInMaskMode() const { return m_isMaskMode; }
171     WrapMode wrapMode() const { return m_wrapMode; }
172     const TransformationMatrix& patternTransform() const { return m_patternTransform; }
173
174 private:
175 #if USE(TEXTURE_MAPPER_GL)
176     static PassOwnPtr<TextureMapper> platformCreateAccelerated();
177 #else
178     static PassOwnPtr<TextureMapper> platformCreateAccelerated()
179     {
180         return PassOwnPtr<TextureMapper>();
181     }
182 #endif
183     InterpolationQuality m_interpolationQuality;
184     TextDrawingModeFlags m_textDrawingMode;
185     OwnPtr<BitmapTexturePool> m_texturePool;
186     AccelerationMode m_accelerationMode;
187     bool m_isMaskMode;
188     TransformationMatrix m_patternTransform;
189     WrapMode m_wrapMode;
190 };
191
192 }
193
194 #endif
195
196 #endif