[Qt] Set WebCore imagedecoders as default and add fallback to QImageDecoder
[WebKit-https.git] / Source / WebCore / platform / image-decoders / ImageDecoder.h
1 /*
2  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
3  * Copyright (C) 2008-2009 Torch Mobile, Inc.
4  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
5  * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
20  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
24  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #ifndef ImageDecoder_h
30 #define ImageDecoder_h
31
32 #include "IntRect.h"
33 #include "ImageSource.h"
34 #include "PlatformString.h"
35 #include "SharedBuffer.h"
36 #include <wtf/Assertions.h>
37 #include <wtf/RefPtr.h>
38 #include <wtf/Vector.h>
39
40 #if USE(SKIA)
41 #include "NativeImageSkia.h"
42 #include "SkColorPriv.h"
43 #endif
44
45 namespace WebCore {
46
47     typedef Vector<char> ColorProfile;
48
49     // ImageFrame represents the decoded image data.  This buffer is what all
50     // decoders write a single frame into.
51     class ImageFrame {
52     public:
53         enum FrameStatus { FrameEmpty, FramePartial, FrameComplete };
54         enum FrameDisposalMethod {
55             // If you change the numeric values of these, make sure you audit
56             // all users, as some users may cast raw values to/from these
57             // constants.
58             DisposeNotSpecified,      // Leave frame in framebuffer
59             DisposeKeep,              // Leave frame in framebuffer
60             DisposeOverwriteBgcolor,  // Clear frame to transparent
61             DisposeOverwritePrevious  // Clear frame to previous framebuffer
62                                       // contents
63         };
64 #if USE(SKIA)
65         typedef uint32_t PixelData;
66 #else
67         typedef unsigned PixelData;
68 #endif
69
70         ImageFrame();
71
72         ImageFrame(const ImageFrame& other) { operator=(other); }
73
74         // For backends which refcount their data, this operator doesn't need to
75         // create a new copy of the image data, only increase the ref count.
76         ImageFrame& operator=(const ImageFrame& other);
77
78         // These do not touch other metadata, only the raw pixel data.
79         void clearPixelData();
80         void zeroFillPixelData();
81
82         // Makes this frame have an independent copy of the provided image's
83         // pixel data, so that modifications in one frame are not reflected in
84         // the other.  Returns whether the copy succeeded.
85         bool copyBitmapData(const ImageFrame&);
86
87         // Makes this frame reference the provided image's pixel data, so that
88         // modifications in one frame are reflected in the other.
89         void copyReferenceToBitmapData(const ImageFrame&);
90
91         // Copies the pixel data at [(startX, startY), (endX, startY)) to the
92         // same X-coordinates on each subsequent row up to but not including
93         // endY.
94         void copyRowNTimes(int startX, int endX, int startY, int endY)
95         {
96             ASSERT(startX < width());
97             ASSERT(endX <= width());
98             ASSERT(startY < height());
99             ASSERT(endY <= height());
100             const int rowBytes = (endX - startX) * sizeof(PixelData);
101             const PixelData* const startAddr = getAddr(startX, startY);
102             for (int destY = startY + 1; destY < endY; ++destY)
103                 memcpy(getAddr(startX, destY), startAddr, rowBytes);
104         }
105
106         // Allocates space for the pixel data.  Must be called before any pixels
107         // are written.  Must only be called once.  Returns whether allocation
108         // succeeded.
109         bool setSize(int newWidth, int newHeight);
110
111         // Returns a caller-owned pointer to the underlying native image data.
112         // (Actual use: This pointer will be owned by BitmapImage and freed in
113         // FrameData::clear()).
114         NativeImagePtr asNewNativeImage() const;
115
116         bool hasAlpha() const;
117         const IntRect& originalFrameRect() const { return m_originalFrameRect; }
118         FrameStatus status() const { return m_status; }
119         unsigned duration() const { return m_duration; }
120         FrameDisposalMethod disposalMethod() const { return m_disposalMethod; }
121         bool premultiplyAlpha() const { return m_premultiplyAlpha; }
122
123         void setHasAlpha(bool alpha);
124         void setColorProfile(const ColorProfile&);
125         void setOriginalFrameRect(const IntRect& r) { m_originalFrameRect = r; }
126         void setStatus(FrameStatus status);
127         void setDuration(unsigned duration) { m_duration = duration; }
128         void setDisposalMethod(FrameDisposalMethod method) { m_disposalMethod = method; }
129         void setPremultiplyAlpha(bool premultiplyAlpha) { m_premultiplyAlpha = premultiplyAlpha; }
130
131         inline void setRGBA(int x, int y, unsigned r, unsigned g, unsigned b, unsigned a)
132         {
133             setRGBA(getAddr(x, y), r, g, b, a);
134         }
135
136         inline PixelData* getAddr(int x, int y)
137         {
138 #if USE(SKIA)
139             return m_bitmap.bitmap().getAddr32(x, y);
140 #else
141             return m_bytes + (y * width()) + x;
142 #endif
143         }
144     private:
145 #if USE(CG)
146         typedef RetainPtr<CFMutableDataRef> NativeBackingStore;
147 #else
148         typedef Vector<PixelData> NativeBackingStore;
149 #endif
150
151         int width() const;
152         int height() const;
153
154         inline void setRGBA(PixelData* dest, unsigned r, unsigned g, unsigned b, unsigned a)
155         {
156             if (m_premultiplyAlpha && !a)
157                 *dest = 0;
158             else {
159                 if (m_premultiplyAlpha && a < 255) {
160                     float alphaPercent = a / 255.0f;
161                     r = static_cast<unsigned>(r * alphaPercent);
162                     g = static_cast<unsigned>(g * alphaPercent);
163                     b = static_cast<unsigned>(b * alphaPercent);
164                 }
165 #if USE(SKIA)
166                 // we are sure to call the NoCheck version, since we may
167                 // deliberately pass non-premultiplied values, and we don't want
168                 // an assert.
169                 *dest = SkPackARGB32NoCheck(a, r, g, b);
170 #else
171                 *dest = (a << 24 | r << 16 | g << 8 | b);
172 #endif
173             }
174         }
175
176 #if USE(SKIA)
177         NativeImageSkia m_bitmap;
178 #if PLATFORM(CHROMIUM) && OS(DARWIN)
179         ColorProfile m_colorProfile;
180 #endif
181 #else
182         NativeBackingStore m_backingStore;
183         PixelData* m_bytes; // The memory is backed by m_backingStore.
184         IntSize m_size;
185         bool m_hasAlpha;
186         ColorProfile m_colorProfile;
187 #endif
188         IntRect m_originalFrameRect; // This will always just be the entire
189                                      // buffer except for GIF frames whose
190                                      // original rect was smaller than the
191                                      // overall image size.
192         FrameStatus m_status;
193         unsigned m_duration;
194         FrameDisposalMethod m_disposalMethod;
195         bool m_premultiplyAlpha;
196     };
197
198     // ImageDecoder is a base for all format-specific decoders
199     // (e.g. JPEGImageDecoder).  This base manages the ImageFrame cache.
200     //
201     // ENABLE(IMAGE_DECODER_DOWN_SAMPLING) allows image decoders to downsample
202     // at decode time.  Image decoders will downsample any images larger than
203     // |m_maxNumPixels|.  FIXME: Not yet supported by all decoders.
204     class ImageDecoder {
205         WTF_MAKE_NONCOPYABLE(ImageDecoder); WTF_MAKE_FAST_ALLOCATED;
206     public:
207         ImageDecoder(ImageSource::AlphaOption alphaOption, ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
208             : m_scaled(false)
209             , m_premultiplyAlpha(alphaOption == ImageSource::AlphaPremultiplied)
210             , m_ignoreGammaAndColorProfile(gammaAndColorProfileOption == ImageSource::GammaAndColorProfileIgnored)
211             , m_sizeAvailable(false)
212             , m_maxNumPixels(-1)
213             , m_isAllDataReceived(false)
214             , m_failed(false) { }
215
216         virtual ~ImageDecoder() { }
217
218         // Returns a caller-owned decoder of the appropriate type.  Returns 0 if
219         // we can't sniff a supported type from the provided data (possibly
220         // because there isn't enough data yet).
221         static ImageDecoder* create(const SharedBuffer& data, ImageSource::AlphaOption, ImageSource::GammaAndColorProfileOption);
222
223         virtual String filenameExtension() const = 0;
224
225         bool isAllDataReceived() const { return m_isAllDataReceived; }
226
227         virtual void setData(SharedBuffer* data, bool allDataReceived)
228         {
229             if (m_failed)
230                 return;
231             m_data = data;
232             m_isAllDataReceived = allDataReceived;
233         }
234
235         // Lazily-decodes enough of the image to get the size (if possible).
236         // FIXME: Right now that has to be done by each subclass; factor the
237         // decode call out and use it here.
238         virtual bool isSizeAvailable()
239         {
240             return !m_failed && m_sizeAvailable;
241         }
242
243         virtual IntSize size() const { return m_size; }
244
245         IntSize scaledSize() const
246         {
247             return m_scaled ? IntSize(m_scaledColumns.size(), m_scaledRows.size()) : size();
248         }
249
250         // This will only differ from size() for ICO (where each frame is a
251         // different icon) or other formats where different frames are different
252         // sizes.  This does NOT differ from size() for GIF, since decoding GIFs
253         // composites any smaller frames against previous frames to create full-
254         // size frames.
255         virtual IntSize frameSizeAtIndex(size_t) const
256         {
257             return size();
258         }
259
260         // Returns whether the size is legal (i.e. not going to result in
261         // overflow elsewhere).  If not, marks decoding as failed.
262         virtual bool setSize(unsigned width, unsigned height)
263         {
264             if (isOverSize(width, height))
265                 return setFailed();
266             m_size = IntSize(width, height);
267             m_sizeAvailable = true;
268             return true;
269         }
270
271         // Lazily-decodes enough of the image to get the frame count (if
272         // possible), without decoding the individual frames.
273         // FIXME: Right now that has to be done by each subclass; factor the
274         // decode call out and use it here.
275         virtual size_t frameCount() { return 1; }
276
277         virtual int repetitionCount() const { return cAnimationNone; }
278
279         // Decodes as much of the requested frame as possible, and returns an
280         // ImageDecoder-owned pointer.
281         virtual ImageFrame* frameBufferAtIndex(size_t) = 0;
282
283         void setIgnoreGammaAndColorProfile(bool flag) { m_ignoreGammaAndColorProfile = flag; }
284         bool ignoresGammaAndColorProfile() const { return m_ignoreGammaAndColorProfile; }
285
286         enum { iccColorProfileHeaderLength = 128 };
287
288         static bool rgbColorProfile(const char* profileData, unsigned profileLength)
289         {
290             ASSERT(profileLength >= iccColorProfileHeaderLength);
291
292             return !memcmp(&profileData[16], "RGB ", 4);
293         }
294
295         static bool inputDeviceColorProfile(const char* profileData, unsigned profileLength)
296         {
297             ASSERT(profileLength >= iccColorProfileHeaderLength);
298
299             return !memcmp(&profileData[12], "mntr", 4) || !memcmp(&profileData[12], "scnr", 4);
300         }
301
302         // Sets the "decode failure" flag.  For caller convenience (since so
303         // many callers want to return false after calling this), returns false
304         // to enable easy tailcalling.  Subclasses may override this to also
305         // clean up any local data.
306         virtual bool setFailed()
307         {
308             m_failed = true;
309             return false;
310         }
311
312         bool failed() const { return m_failed; }
313
314         // Clears decoded pixel data from before the provided frame unless that
315         // data may be needed to decode future frames (e.g. due to GIF frame
316         // compositing).
317         virtual void clearFrameBufferCache(size_t) { }
318
319 #if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
320         void setMaxNumPixels(int m) { m_maxNumPixels = m; }
321 #endif
322
323     protected:
324         void prepareScaleDataIfNecessary();
325         int upperBoundScaledX(int origX, int searchStart = 0);
326         int lowerBoundScaledX(int origX, int searchStart = 0);
327         int upperBoundScaledY(int origY, int searchStart = 0);
328         int lowerBoundScaledY(int origY, int searchStart = 0);
329         int scaledY(int origY, int searchStart = 0);
330
331         RefPtr<SharedBuffer> m_data; // The encoded data.
332         Vector<ImageFrame> m_frameBufferCache;
333         ColorProfile m_colorProfile;
334         bool m_scaled;
335         Vector<int> m_scaledColumns;
336         Vector<int> m_scaledRows;
337         bool m_premultiplyAlpha;
338         bool m_ignoreGammaAndColorProfile;
339
340     private:
341         // Some code paths compute the size of the image as "width * height * 4"
342         // and return it as a (signed) int.  Avoid overflow.
343         static bool isOverSize(unsigned width, unsigned height)
344         {
345             unsigned long long total_size = static_cast<unsigned long long>(width)
346                                           * static_cast<unsigned long long>(height);
347             return total_size > ((1 << 29) - 1);
348         }
349
350         IntSize m_size;
351         bool m_sizeAvailable;
352         int m_maxNumPixels;
353         bool m_isAllDataReceived;
354         bool m_failed;
355     };
356
357 } // namespace WebCore
358
359 #endif