2009-06-10 Simon Hausmann <simon.hausmann@nokia.com>
[WebKit-https.git] / WebCore / platform / image-decoders / ImageDecoder.h
1 /*
2  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef ImageDecoder_h
27 #define ImageDecoder_h
28
29 #include "IntRect.h"
30 #include "ImageSource.h"
31 #include "PlatformString.h"
32 #include "SharedBuffer.h"
33 #include <wtf/Assertions.h>
34 #include <wtf/RefPtr.h>
35 #include <wtf/Vector.h>
36
37 namespace WebCore {
38
39     typedef Vector<unsigned> RGBA32Array;
40
41     // The RGBA32Buffer object represents the decoded image data in RGBA32 format.  This buffer is what all
42     // decoders write a single frame into.  Frames are then instantiated for drawing by being handed this buffer.
43     class RGBA32Buffer {
44     public:
45         enum FrameStatus { FrameEmpty, FramePartial, FrameComplete };
46
47         enum FrameDisposalMethod {
48             // If you change the numeric values of these, make sure you audit all
49             // users, as some users may cast raw values to/from these constants.
50             DisposeNotSpecified,       // Leave frame in framebuffer
51             DisposeKeep,               // Leave frame in framebuffer
52             DisposeOverwriteBgcolor,   // Clear frame to transparent
53             DisposeOverwritePrevious,  // Clear frame to previous framebuffer contents
54         };
55
56         RGBA32Buffer()
57             : m_status(FrameEmpty)
58             , m_duration(0)
59             , m_disposalMethod(DisposeNotSpecified)
60             , m_hasAlpha(false)
61         {
62         } 
63
64         void clear() {
65           m_bytes.clear();
66           m_status = FrameEmpty;
67           // NOTE: Do not reset other members here; clearFrameBufferCache() calls
68           // this to free the bitmap data, but other functions like
69           // initFrameBuffer() and frameComplete() may still need to read other
70           // metadata out of this frame later.
71         }
72
73         // This function creates a new copy of the image data in |other|, so the
74         // two images can be modified independently.
75         void copyBitmapData(const RGBA32Buffer& other)
76         {
77             if (this == &other)
78                 return;
79
80             m_bytes = other.m_bytes;
81             m_hasAlpha = other.m_hasAlpha;
82         }
83
84         const RGBA32Array& bytes() const { return m_bytes; }
85         RGBA32Array& bytes() { return m_bytes; }
86
87         // Must be called before any pixels are written. Will return true on
88         // success, false if the memory allocation fails.
89         bool setSize(int width, int height)
90         {
91             // NOTE: This has no way to check for allocation failure if the
92             // requested size was too big...
93             m_bytes.resize(width * height);
94
95             // Clear the image.
96             m_bytes.fill(0);
97             m_hasAlpha = true;
98
99             return true;
100         }
101
102         const IntRect& rect() const { return m_rect; }
103         FrameStatus status() const { return m_status; }
104         unsigned duration() const { return m_duration; }
105         FrameDisposalMethod disposalMethod() const { return m_disposalMethod; }
106         bool hasAlpha() const { return m_hasAlpha; }
107
108         void setRect(const IntRect& r) { m_rect = r; }
109         void setStatus(FrameStatus s) { m_status = s; }
110         void setDuration(unsigned duration) { m_duration = duration; }
111         void setDisposalMethod(FrameDisposalMethod method) { m_disposalMethod = method; }
112         void setHasAlpha(bool alpha) { m_hasAlpha = alpha; }
113
114         static void setRGBA(unsigned& pos, unsigned r, unsigned g, unsigned b, unsigned a)
115         {
116             // We store this data pre-multiplied.
117             if (a == 0)
118                 pos = 0;
119             else {
120                 if (a < 255) {
121                     float alphaPercent = a / 255.0f;
122                     r = static_cast<unsigned>(r * alphaPercent);
123                     g = static_cast<unsigned>(g * alphaPercent);
124                     b = static_cast<unsigned>(b * alphaPercent);
125                 }
126                 pos = (a << 24 | r << 16 | g << 8 | b);
127             }
128         }
129
130     private:
131         RGBA32Array m_bytes;
132         IntRect m_rect;    // The rect of the original specified frame within the overall buffer.
133                            // This will always just be the entire buffer except for GIF frames
134                            // whose original rect was smaller than the overall image size.
135         FrameStatus m_status; // Whether or not this frame is completely finished decoding.
136         unsigned m_duration; // The animation delay.
137         FrameDisposalMethod m_disposalMethod; // What to do with this frame's data when initializing the next frame.
138         bool m_hasAlpha; // Whether or not any of the pixels in the buffer have transparency.
139     };
140
141     // The ImageDecoder class represents a base class for specific image format decoders
142     // (e.g., GIF, JPG, PNG, ICO) to derive from.  All decoders decode into RGBA32 format
143     // and the base class manages the RGBA32 frame cache.
144     class ImageDecoder {
145     public:
146         ImageDecoder()
147             : m_failed(false)
148             , m_sizeAvailable(false)
149         {
150         }
151
152         virtual ~ImageDecoder() {}
153
154         // The the filename extension usually associated with an undecoded image of this type.
155         virtual String filenameExtension() const = 0;
156
157         // All specific decoder plugins must do something with the data they are given.
158         virtual void setData(SharedBuffer* data, bool allDataReceived) { m_data = data; }
159
160         // Whether or not the size information has been decoded yet. This default
161         // implementation just returns true if the size has been set and we have not
162         // seen a failure. Decoders may want to override this to lazily decode
163         // enough of the image to get the size.
164         virtual bool isSizeAvailable() const
165         {
166             return !m_failed && m_sizeAvailable; 
167         }
168
169         // Requests the size.
170         virtual IntSize size() const
171         {
172             // Requesting the size of an invalid bitmap is meaningless.
173             ASSERT(!m_failed);
174             return m_size;
175         }
176
177         // The total number of frames for the image.  Classes that support multiple frames
178         // will scan the image data for the answer if they need to (without necessarily
179         // decoding all of the individual frames).
180         virtual int frameCount() { return 1; }
181
182         // The number of repetitions to perform for an animation loop.
183         virtual int repetitionCount() const { return cAnimationNone; }
184
185         // Called to obtain the RGBA32Buffer full of decoded data for rendering.  The
186         // decoder plugin will decode as much of the frame as it can before handing
187         // back the buffer.
188         virtual RGBA32Buffer* frameBufferAtIndex(size_t index) = 0;
189
190         // Whether or not the underlying image format even supports alpha transparency.
191         virtual bool supportsAlpha() const { return true; }
192
193         bool failed() const { return m_failed; }
194         void setFailed() { m_failed = true; }
195
196         // Wipe out frames in the frame buffer cache before |clearBeforeFrame|,
197         // assuming this can be done without breaking decoding.  Different decoders
198         // place different restrictions on what frames are safe to destroy, so this
199         // is left to them to implement.
200         // For convenience's sake, we provide a default (empty) implementation,
201         // since in practice only GIFs will ever use this.
202         virtual void clearFrameBufferCache(size_t clearBeforeFrame) { }
203
204     protected:
205         // Called by the image decoders to set their decoded size, this also check
206         // the size for validity. It will return true if the size was set, or false
207         // if there is an error. On error, the m_failed flag will be set and the
208         // caller should immediately stop decoding.
209         bool setSize(unsigned width, unsigned height)
210         {
211             if (isOverSize(width, height)) {
212                 m_failed = true;
213                 return false;
214             }
215             m_size = IntSize(width, height);
216             m_sizeAvailable = true;
217             return true;
218         }
219
220         RefPtr<SharedBuffer> m_data; // The encoded data.
221         Vector<RGBA32Buffer> m_frameBufferCache;
222         mutable bool m_failed;
223         IntSize m_size;
224         bool m_sizeAvailable;
225
226     private:
227         // Some code paths compute the size of the image as "width * height * 4"
228         // and return it as a (signed) int.  Avoid overflow.
229         static bool isOverSize(unsigned width, unsigned height)
230         {
231             // width * height must not exceed (2 ^ 29) - 1, so that we don't
232             // overflow when we multiply by 4.
233             unsigned long long total_size = static_cast<unsigned long long>(width)
234                                           * static_cast<unsigned long long>(height);
235             return total_size > ((1 << 29) - 1);
236         }
237     };
238
239 } // namespace WebCore
240
241 #endif