GIFImageReader to read from source data directly
[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 "PlatformScreen.h"
35 #include "SharedBuffer.h"
36 #include <wtf/Assertions.h>
37 #include <wtf/RefPtr.h>
38 #include <wtf/Vector.h>
39 #include <wtf/text/WTFString.h>
40
41 #if USE(SKIA)
42 #include "NativeImageSkia.h"
43 #include "SkColorPriv.h"
44 #endif
45
46 #if USE(QCMSLIB)
47 #include "qcms.h"
48 #if OS(DARWIN)
49 #include "GraphicsContextCG.h"
50 #include <ApplicationServices/ApplicationServices.h>
51 #include <wtf/RetainPtr.h>
52 #endif
53 #endif
54
55 namespace WebCore {
56
57     // ImageFrame represents the decoded image data.  This buffer is what all
58     // decoders write a single frame into.
59     class ImageFrame {
60     public:
61         enum FrameStatus { FrameEmpty, FramePartial, FrameComplete };
62         enum FrameDisposalMethod {
63             // If you change the numeric values of these, make sure you audit
64             // all users, as some users may cast raw values to/from these
65             // constants.
66             DisposeNotSpecified,      // Leave frame in framebuffer
67             DisposeKeep,              // Leave frame in framebuffer
68             DisposeOverwriteBgcolor,  // Clear frame to transparent
69             DisposeOverwritePrevious  // Clear frame to previous framebuffer
70                                       // contents
71         };
72 #if USE(SKIA)
73         typedef uint32_t PixelData;
74 #else
75         typedef unsigned PixelData;
76 #endif
77
78         ImageFrame();
79
80         ImageFrame(const ImageFrame& other) { operator=(other); }
81
82         // For backends which refcount their data, this operator doesn't need to
83         // create a new copy of the image data, only increase the ref count.
84         ImageFrame& operator=(const ImageFrame& other);
85
86         // These do not touch other metadata, only the raw pixel data.
87         void clearPixelData();
88         void zeroFillPixelData();
89
90         // Makes this frame have an independent copy of the provided image's
91         // pixel data, so that modifications in one frame are not reflected in
92         // the other.  Returns whether the copy succeeded.
93         bool copyBitmapData(const ImageFrame&);
94
95         // Copies the pixel data at [(startX, startY), (endX, startY)) to the
96         // same X-coordinates on each subsequent row up to but not including
97         // endY.
98         void copyRowNTimes(int startX, int endX, int startY, int endY)
99         {
100             ASSERT(startX < width());
101             ASSERT(endX <= width());
102             ASSERT(startY < height());
103             ASSERT(endY <= height());
104             const int rowBytes = (endX - startX) * sizeof(PixelData);
105             const PixelData* const startAddr = getAddr(startX, startY);
106             for (int destY = startY + 1; destY < endY; ++destY)
107                 memcpy(getAddr(startX, destY), startAddr, rowBytes);
108         }
109
110         // Allocates space for the pixel data.  Must be called before any pixels
111         // are written.  Must only be called once.  Returns whether allocation
112         // succeeded.
113         bool setSize(int newWidth, int newHeight);
114
115         // Returns a caller-owned pointer to the underlying native image data.
116         // (Actual use: This pointer will be owned by BitmapImage and freed in
117         // FrameData::clear()).
118         NativeImagePtr asNewNativeImage() const;
119
120         bool hasAlpha() const;
121         const IntRect& originalFrameRect() const { return m_originalFrameRect; }
122         FrameStatus status() const { return m_status; }
123         unsigned duration() const { return m_duration; }
124         FrameDisposalMethod disposalMethod() const { return m_disposalMethod; }
125         bool premultiplyAlpha() const { return m_premultiplyAlpha; }
126         void reportMemoryUsage(MemoryObjectInfo*) const;
127
128         void setHasAlpha(bool alpha);
129         void setColorProfile(const ColorProfile&);
130         void setOriginalFrameRect(const IntRect& r) { m_originalFrameRect = r; }
131         void setStatus(FrameStatus status);
132         void setDuration(unsigned duration) { m_duration = duration; }
133         void setDisposalMethod(FrameDisposalMethod method) { m_disposalMethod = method; }
134         void setPremultiplyAlpha(bool premultiplyAlpha) { m_premultiplyAlpha = premultiplyAlpha; }
135
136         inline void setRGBA(int x, int y, unsigned r, unsigned g, unsigned b, unsigned a)
137         {
138             setRGBA(getAddr(x, y), r, g, b, a);
139         }
140
141         inline PixelData* getAddr(int x, int y)
142         {
143 #if USE(SKIA)
144             return m_bitmap.bitmap().getAddr32(x, y);
145 #else
146             return m_bytes + (y * width()) + x;
147 #endif
148         }
149
150 #if PLATFORM(CHROMIUM)
151         void setSkBitmap(const SkBitmap& bitmap)
152         {
153             m_bitmap = NativeImageSkia(bitmap, 1);
154         }
155
156         const SkBitmap& getSkBitmap() const
157         {
158             return m_bitmap.bitmap();
159         }
160
161         void setMemoryAllocator(SkBitmap::Allocator* allocator)
162         {
163             m_allocator = allocator;
164         }
165
166         SkBitmap::Allocator* allocator() const { return m_allocator; }
167 #endif
168
169         // Use fix point multiplier instead of integer division or floating point math.
170         // This multipler produces exactly the same result for all values in range 0 - 255.
171         static const unsigned fixPointShift = 24;
172         static const unsigned fixPointMult = static_cast<unsigned>(1.0 / 255.0 * (1 << fixPointShift)) + 1;
173         // Multiplies unsigned value by fixpoint value and converts back to unsigned.
174         static unsigned fixPointUnsignedMultiply(unsigned fixed, unsigned v)
175         {
176             return  (fixed * v) >> fixPointShift;
177         }
178
179         inline void setRGBA(PixelData* dest, unsigned r, unsigned g, unsigned b, unsigned a)
180         {
181             if (m_premultiplyAlpha && a < 255) {
182                 if (!a) {
183                     *dest = 0;
184                     return;
185                 }
186
187                 unsigned alphaMult = a * fixPointMult;
188                 r = fixPointUnsignedMultiply(r, alphaMult);
189                 g = fixPointUnsignedMultiply(g, alphaMult);
190                 b = fixPointUnsignedMultiply(b, alphaMult);
191             }
192 #if USE(SKIA)
193             // Call the "NoCheck" version since we may deliberately pass non-premultiplied
194             // values, and we don't want an assert.
195             *dest = SkPackARGB32NoCheck(a, r, g, b);
196 #else
197             *dest = (a << 24 | r << 16 | g << 8 | b);
198 #endif
199         }
200
201     private:
202         int width() const
203         {
204 #if USE(SKIA)
205             return m_bitmap.bitmap().width();
206 #else
207             return m_size.width();
208 #endif
209         }
210
211         int height() const
212         {
213 #if USE(SKIA)
214             return m_bitmap.bitmap().height();
215 #else
216             return m_size.height();
217 #endif
218         }
219
220 #if USE(SKIA)
221         NativeImageSkia m_bitmap;
222         SkBitmap::Allocator* m_allocator;
223 #else
224         Vector<PixelData> m_backingStore;
225         PixelData* m_bytes; // The memory is backed by m_backingStore.
226         IntSize m_size;
227         // FIXME: Do we need m_colorProfile anymore?
228         ColorProfile m_colorProfile;
229 #endif
230         bool m_hasAlpha;
231         IntRect m_originalFrameRect; // This will always just be the entire
232                                      // buffer except for GIF frames whose
233                                      // original rect was smaller than the
234                                      // overall image size.
235         FrameStatus m_status;
236         unsigned m_duration;
237         FrameDisposalMethod m_disposalMethod;
238         bool m_premultiplyAlpha;
239     };
240
241     // ImageDecoder is a base for all format-specific decoders
242     // (e.g. JPEGImageDecoder).  This base manages the ImageFrame cache.
243     //
244     // ENABLE(IMAGE_DECODER_DOWN_SAMPLING) allows image decoders to downsample
245     // at decode time.  Image decoders will downsample any images larger than
246     // |m_maxNumPixels|.  FIXME: Not yet supported by all decoders.
247     class ImageDecoder {
248         WTF_MAKE_NONCOPYABLE(ImageDecoder); WTF_MAKE_FAST_ALLOCATED;
249     public:
250         ImageDecoder(ImageSource::AlphaOption alphaOption, ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
251             : m_scaled(false)
252             , m_premultiplyAlpha(alphaOption == ImageSource::AlphaPremultiplied)
253             , m_ignoreGammaAndColorProfile(gammaAndColorProfileOption == ImageSource::GammaAndColorProfileIgnored)
254             , m_sizeAvailable(false)
255             , m_maxNumPixels(-1)
256             , m_isAllDataReceived(false)
257             , m_failed(false) { }
258
259         virtual ~ImageDecoder() { }
260
261         // Returns a caller-owned decoder of the appropriate type.  Returns 0 if
262         // we can't sniff a supported type from the provided data (possibly
263         // because there isn't enough data yet).
264         static ImageDecoder* create(const SharedBuffer& data, ImageSource::AlphaOption, ImageSource::GammaAndColorProfileOption);
265
266         virtual String filenameExtension() const = 0;
267
268         bool isAllDataReceived() const { return m_isAllDataReceived; }
269
270         virtual void setData(SharedBuffer* data, bool allDataReceived)
271         {
272             if (m_failed)
273                 return;
274             m_data = data;
275             m_isAllDataReceived = allDataReceived;
276         }
277
278         // Lazily-decodes enough of the image to get the size (if possible).
279         // FIXME: Right now that has to be done by each subclass; factor the
280         // decode call out and use it here.
281         virtual bool isSizeAvailable()
282         {
283             return !m_failed && m_sizeAvailable;
284         }
285
286         virtual IntSize size() const { return m_size; }
287
288         IntSize scaledSize() const
289         {
290             return m_scaled ? IntSize(m_scaledColumns.size(), m_scaledRows.size()) : size();
291         }
292
293         // This will only differ from size() for ICO (where each frame is a
294         // different icon) or other formats where different frames are different
295         // sizes.  This does NOT differ from size() for GIF, since decoding GIFs
296         // composites any smaller frames against previous frames to create full-
297         // size frames.
298         virtual IntSize frameSizeAtIndex(size_t) const
299         {
300             return size();
301         }
302
303         // Returns whether the size is legal (i.e. not going to result in
304         // overflow elsewhere).  If not, marks decoding as failed.
305         virtual bool setSize(unsigned width, unsigned height)
306         {
307             if (isOverSize(width, height))
308                 return setFailed();
309             m_size = IntSize(width, height);
310             m_sizeAvailable = true;
311             return true;
312         }
313
314         // Lazily-decodes enough of the image to get the frame count (if
315         // possible), without decoding the individual frames.
316         // FIXME: Right now that has to be done by each subclass; factor the
317         // decode call out and use it here.
318         virtual size_t frameCount() { return 1; }
319
320         virtual int repetitionCount() const { return cAnimationNone; }
321
322         // Decodes as much of the requested frame as possible, and returns an
323         // ImageDecoder-owned pointer.
324         virtual ImageFrame* frameBufferAtIndex(size_t) = 0;
325
326         // Make the best effort guess to check if the requested frame has alpha channel.
327         virtual bool frameHasAlphaAtIndex(size_t) const;
328
329         // Number of bytes in the decoded frame requested. Return 0 if not yet decoded.
330         virtual unsigned frameBytesAtIndex(size_t) const;
331
332         void setIgnoreGammaAndColorProfile(bool flag) { m_ignoreGammaAndColorProfile = flag; }
333         bool ignoresGammaAndColorProfile() const { return m_ignoreGammaAndColorProfile; }
334
335         ImageOrientation orientation() const { return m_orientation; }
336
337         enum { iccColorProfileHeaderLength = 128 };
338
339         static bool rgbColorProfile(const char* profileData, unsigned profileLength)
340         {
341             ASSERT_UNUSED(profileLength, profileLength >= iccColorProfileHeaderLength);
342
343             return !memcmp(&profileData[16], "RGB ", 4);
344         }
345
346         static bool inputDeviceColorProfile(const char* profileData, unsigned profileLength)
347         {
348             ASSERT_UNUSED(profileLength, profileLength >= iccColorProfileHeaderLength);
349
350             return !memcmp(&profileData[12], "mntr", 4) || !memcmp(&profileData[12], "scnr", 4);
351         }
352
353 #if USE(QCMSLIB)
354         static qcms_profile* qcmsOutputDeviceProfile()
355         {
356             static qcms_profile* outputDeviceProfile = 0;
357
358             static bool qcmsInitialized = false;
359             if (!qcmsInitialized) {
360                 qcmsInitialized = true;
361                 // FIXME: Add optional ICCv4 support.
362 #if OS(DARWIN)
363                 RetainPtr<CGColorSpaceRef> monitorColorSpace(AdoptCF, CGDisplayCopyColorSpace(CGMainDisplayID()));
364                 CFDataRef iccProfile(CGColorSpaceCopyICCProfile(monitorColorSpace.get()));
365                 if (iccProfile) {
366                     size_t length = CFDataGetLength(iccProfile);
367                     const unsigned char* systemProfile = CFDataGetBytePtr(iccProfile);
368                     outputDeviceProfile = qcms_profile_from_memory(systemProfile, length);
369                 }
370 #else
371                 // FIXME: add support for multiple monitors.
372                 ColorProfile profile;
373                 screenColorProfile(profile);
374                 if (!profile.isEmpty())
375                     outputDeviceProfile = qcms_profile_from_memory(profile.data(), profile.size());
376 #endif
377                 if (outputDeviceProfile && qcms_profile_is_bogus(outputDeviceProfile)) {
378                     qcms_profile_release(outputDeviceProfile);
379                     outputDeviceProfile = 0;
380                 }
381                 if (!outputDeviceProfile)
382                     outputDeviceProfile = qcms_profile_sRGB();
383                 if (outputDeviceProfile)
384                     qcms_profile_precache_output_transform(outputDeviceProfile);
385             }
386             return outputDeviceProfile;
387         }
388 #endif
389
390         // Sets the "decode failure" flag.  For caller convenience (since so
391         // many callers want to return false after calling this), returns false
392         // to enable easy tailcalling.  Subclasses may override this to also
393         // clean up any local data.
394         virtual bool setFailed()
395         {
396             m_failed = true;
397             return false;
398         }
399
400         bool failed() const { return m_failed; }
401
402         // Clears decoded pixel data from before the provided frame unless that
403         // data may be needed to decode future frames (e.g. due to GIF frame
404         // compositing).
405         virtual void clearFrameBufferCache(size_t) { }
406
407 #if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
408         void setMaxNumPixels(int m) { m_maxNumPixels = m; }
409 #endif
410
411         // If the image has a cursor hot-spot, stores it in the argument
412         // and returns true. Otherwise returns false.
413         virtual bool hotSpot(IntPoint&) const { return false; }
414
415         virtual void reportMemoryUsage(MemoryObjectInfo*) const;
416
417 #if USE(SKIA)
418         virtual void setMemoryAllocator(SkBitmap::Allocator* allocator)
419         {
420             // FIXME: this doesn't work for images with multiple frames.
421             if (m_frameBufferCache.isEmpty())
422                 m_frameBufferCache.resize(1);
423             m_frameBufferCache[0].setMemoryAllocator(allocator);
424         }
425 #endif
426     protected:
427         void prepareScaleDataIfNecessary();
428         int upperBoundScaledX(int origX, int searchStart = 0);
429         int lowerBoundScaledX(int origX, int searchStart = 0);
430         int upperBoundScaledY(int origY, int searchStart = 0);
431         int lowerBoundScaledY(int origY, int searchStart = 0);
432         int scaledY(int origY, int searchStart = 0);
433
434         RefPtr<SharedBuffer> m_data; // The encoded data.
435         Vector<ImageFrame, 1> m_frameBufferCache;
436         // FIXME: Do we need m_colorProfile any more, for any port?
437         ColorProfile m_colorProfile;
438         bool m_scaled;
439         Vector<int> m_scaledColumns;
440         Vector<int> m_scaledRows;
441         bool m_premultiplyAlpha;
442         bool m_ignoreGammaAndColorProfile;
443         ImageOrientation m_orientation;
444
445     private:
446         // Some code paths compute the size of the image as "width * height * 4"
447         // and return it as a (signed) int.  Avoid overflow.
448         static bool isOverSize(unsigned width, unsigned height)
449         {
450             unsigned long long total_size = static_cast<unsigned long long>(width)
451                                           * static_cast<unsigned long long>(height);
452             return total_size > ((1 << 29) - 1);
453         }
454
455         IntSize m_size;
456         bool m_sizeAvailable;
457         int m_maxNumPixels;
458         bool m_isAllDataReceived;
459         bool m_failed;
460     };
461
462 } // namespace WebCore
463
464 #endif