2007-11-26 Peter Kasting <zerodpx@gmail.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 IMAGE_DECODER_H_
27 #define IMAGE_DECODER_H_
28
29 #include "IntRect.h"
30 #include "ImageSource.h"
31 #include "SharedBuffer.h"
32 #include <wtf/Vector.h>
33
34 namespace WebCore {
35
36 typedef Vector<unsigned> RGBA32Array;
37
38 // The RGBA32Buffer object represents the decoded image data in RGBA32 format.  This buffer is what all
39 // decoders write a single frame into.  Frames are then instantiated for drawing by being handed this buffer.
40 class RGBA32Buffer
41 {
42 public:
43     enum FrameStatus { FrameEmpty, FramePartial, FrameComplete };
44     enum FrameDisposalMethod {
45         // If you change the numeric values of these, make sure you audit all
46         // users, as some users may cast raw values to/from these constants.
47         DisposeNotSpecified = 0,       // Leave frame in framebuffer
48         DisposeKeep = 1,               // Leave frame in framebuffer
49         DisposeOverwriteBgcolor = 2,   // Clear frame to transparent
50         DisposeOverwritePrevious = 3,  // Clear frame to previous framebuffer contents
51     };
52
53     RGBA32Buffer() : m_height(0), m_status(FrameEmpty), m_duration(0),
54                      m_disposalMethod(DisposeNotSpecified), m_hasAlpha(false)
55     {} 
56
57     const RGBA32Array& bytes() const { return m_bytes; }
58     RGBA32Array& bytes() { return m_bytes; }
59     const IntRect& rect() const { return m_rect; }
60     unsigned height() const { return m_height; }
61     FrameStatus status() const { return m_status; }
62     unsigned duration() const { return m_duration; }
63     FrameDisposalMethod disposalMethod() const { return m_disposalMethod; }
64     bool hasAlpha() const { return m_hasAlpha; }
65
66     void setRect(const IntRect& r) { m_rect = r; }
67     void ensureHeight(unsigned rowIndex) { if (rowIndex > m_height) m_height = rowIndex; }
68     void setStatus(FrameStatus s) { m_status = s; }
69     void setDuration(unsigned duration) { m_duration = duration; }
70     void setDisposalMethod(FrameDisposalMethod method) { m_disposalMethod = method; }
71     void setHasAlpha(bool alpha) { m_hasAlpha = alpha; }
72
73     static void setRGBA(unsigned& pos, unsigned r, unsigned g, unsigned b, unsigned a)
74     {
75         // We store this data pre-multiplied.
76         if (a == 0)
77             pos = 0;
78         else {
79             if (a < 255) {
80                 float alphaPercent = a / 255.0f;
81                 r = static_cast<unsigned>(r * alphaPercent);
82                 g = static_cast<unsigned>(g * alphaPercent);
83                 b = static_cast<unsigned>(b * alphaPercent);
84             }
85             pos = (a << 24 | r << 16 | g << 8 | b);
86         }
87     }
88
89 private:
90     RGBA32Array m_bytes;
91     IntRect m_rect;    // The rect of the original specified frame within the overall buffer.
92                        // This will always just be the entire buffer except for GIF frames
93                        // whose original rect was smaller than the overall image size.
94     unsigned m_height; // The height (the number of rows we've fully decoded).
95     FrameStatus m_status; // Whether or not this frame is completely finished decoding.
96     unsigned m_duration; // The animation delay.
97     FrameDisposalMethod m_disposalMethod; // What to do with this frame's data when initializing the next frame.
98     bool m_hasAlpha; // Whether or not any of the pixels in the buffer have transparency.
99 };
100
101 // The ImageDecoder class represents a base class for specific image format decoders
102 // (e.g., GIF, JPG, PNG, ICO) to derive from.  All decoders decode into RGBA32 format
103 // and the base class manages the RGBA32 frame cache.
104 class ImageDecoder
105 {
106 public:
107     ImageDecoder() :m_sizeAvailable(false), m_failed(false) {}
108     virtual ~ImageDecoder() {}
109
110     // All specific decoder plugins must do something with the data they are given.
111     virtual void setData(SharedBuffer* data, bool allDataReceived) { m_data = data; }
112
113     // Whether or not the size information has been decoded yet.
114     virtual bool isSizeAvailable() const = 0;
115
116     // Requests the size.
117     virtual IntSize size() const { return m_size; }
118
119     // The total number of frames for the image.  Classes that support multiple frames
120     // will scan the image data for the answer if they need to (without necessarily
121     // decoding all of the individual frames).
122     virtual int frameCount() { return 1; }
123
124     // The number of repetitions to perform for an animation loop.
125     virtual int repetitionCount() const { return cAnimationNone; }
126
127     // Called to obtain the RGBA32Buffer full of decoded data for rendering.  The
128     // decoder plugin will decode as much of the frame as it can before handing
129     // back the buffer.
130     virtual RGBA32Buffer* frameBufferAtIndex(size_t index) = 0;
131
132     // Whether or not the underlying image format even supports alpha transparency.
133     virtual bool supportsAlpha() const { return true; }
134
135     bool failed() const { return m_failed; }
136     void setFailed() { m_failed = true; }
137
138 protected:
139     RefPtr<SharedBuffer> m_data; // The encoded data.
140     Vector<RGBA32Buffer> m_frameBufferCache;
141     bool m_sizeAvailable;
142     mutable bool m_failed;
143     IntSize m_size;
144 };
145
146 }
147
148 #endif