Unreviewed: Chromium build fix.
[WebKit-https.git] / WebCore / platform / image-decoders / ImageDecoder.cpp
1 /*
2  * Copyright (C) 2008-2009 Torch Mobile, Inc.
3  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
4  *
5  *  This library is free software; you can redistribute it and/or
6  *  modify it under the terms of the GNU Library General Public
7  *  License as published by the Free Software Foundation; either
8  *  version 2 of the License, or (at your option) any later version.
9  *
10  *  This library is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  Library General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Library General Public License
16  *  along with this library; see the file COPYING.LIB.  If not, write to
17  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  *  Boston, MA 02110-1301, USA.
19  *
20  */
21
22 #include "config.h"
23
24 #include "ImageDecoder.h"
25
26 #include <algorithm>
27 #include <cmath>
28
29 #include "BMPImageDecoder.h"
30 #include "GIFImageDecoder.h"
31 #include "ICOImageDecoder.h"
32 #include "JPEGImageDecoder.h"
33 #include "PNGImageDecoder.h"
34 #include "SharedBuffer.h"
35
36 using namespace std;
37
38 namespace WebCore {
39
40 static unsigned copyFromSharedBuffer(char* buffer, unsigned bufferLength, const SharedBuffer& sharedBuffer, unsigned offset)
41 {
42     unsigned bytesExtracted = 0;
43     const char* moreData;
44     while (unsigned moreDataLength = sharedBuffer.getSomeData(moreData, offset)) {
45         unsigned bytesToCopy = min(bufferLength - bytesExtracted, moreDataLength);
46         memcpy(buffer + bytesExtracted, moreData, bytesToCopy);
47         bytesExtracted += bytesToCopy;
48         if (bytesExtracted == bufferLength)
49             break;
50         offset += bytesToCopy;
51     }
52     return bytesExtracted;
53 }
54
55 ImageDecoder* ImageDecoder::create(const SharedBuffer& data)
56 {
57     // We need at least 4 bytes to figure out what kind of image we're dealing
58     // with.
59     static const unsigned maxMarkerLength = 4;
60     char contents[maxMarkerLength];
61     unsigned length = copyFromSharedBuffer(contents, maxMarkerLength, data, 0);
62     if (length < maxMarkerLength)
63         return 0;
64
65     // GIFs begin with GIF8(7 or 9).
66     if (strncmp(contents, "GIF8", 4) == 0)
67         return new GIFImageDecoder();
68
69     // Test for PNG.
70     if (!memcmp(contents, "\x89\x50\x4E\x47", 4))
71         return new PNGImageDecoder();
72
73     // JPEG
74     if (!memcmp(contents, "\xFF\xD8\xFF", 3))
75         return new JPEGImageDecoder();
76
77     // BMP
78     if (strncmp(contents, "BM", 2) == 0)
79         return new BMPImageDecoder();
80
81     // ICOs always begin with a 2-byte 0 followed by a 2-byte 1.
82     // CURs begin with 2-byte 0 followed by 2-byte 2.
83     if (!memcmp(contents, "\x00\x00\x01\x00", 4) || !memcmp(contents, "\x00\x00\x02\x00", 4))
84         return new ICOImageDecoder();
85
86     // Give up. We don't know what the heck this is.
87     return 0;
88 }
89
90 #if !PLATFORM(SKIA)
91
92 RGBA32Buffer::RGBA32Buffer()
93     : m_hasAlpha(false)
94     , m_status(FrameEmpty)
95     , m_duration(0)
96     , m_disposalMethod(DisposeNotSpecified)
97 {
98
99
100 void RGBA32Buffer::clear()
101 {
102     m_bytes.clear();
103     m_status = FrameEmpty;
104     // NOTE: Do not reset other members here; clearFrameBufferCache() calls this
105     // to free the bitmap data, but other functions like initFrameBuffer() and
106     // frameComplete() may still need to read other metadata out of this frame
107     // later.
108 }
109
110 void RGBA32Buffer::zeroFill()
111 {
112     m_bytes.fill(0);
113     m_hasAlpha = true;
114 }
115
116 void RGBA32Buffer::copyBitmapData(const RGBA32Buffer& other)
117 {
118     if (this == &other)
119         return;
120
121     m_bytes = other.m_bytes;
122     m_size = other.m_size;
123     setHasAlpha(other.m_hasAlpha);
124 }
125
126 bool RGBA32Buffer::setSize(int newWidth, int newHeight)
127 {
128     // NOTE: This has no way to check for allocation failure if the requested
129     // size was too big...
130     m_bytes.resize(newWidth * newHeight);
131     m_size = IntSize(newWidth, newHeight);
132
133     // Zero the image.
134     zeroFill();
135
136     return true;
137 }
138
139 bool RGBA32Buffer::hasAlpha() const
140 {
141     return m_hasAlpha;
142 }
143
144 void RGBA32Buffer::setHasAlpha(bool alpha)
145 {
146     m_hasAlpha = alpha;
147 }
148
149 void RGBA32Buffer::setStatus(FrameStatus status)
150 {
151     m_status = status;
152 }
153
154 RGBA32Buffer& RGBA32Buffer::operator=(const RGBA32Buffer& other)
155 {
156     if (this == &other)
157         return *this;
158
159     copyBitmapData(other);
160     setRect(other.rect());
161     setStatus(other.status());
162     setDuration(other.duration());
163     setDisposalMethod(other.disposalMethod());
164     return *this;
165 }
166
167 int RGBA32Buffer::width() const
168 {
169     return m_size.width();
170 }
171
172 int RGBA32Buffer::height() const
173 {
174     return m_size.height();
175 }
176
177 #endif
178
179 namespace {
180
181 enum MatchType {
182     Exact,
183     UpperBound,
184     LowerBound
185 };
186
187 inline void fillScaledValues(Vector<int>& scaledValues, double scaleRate, int length)
188 {
189     double inflateRate = 1. / scaleRate;
190     scaledValues.reserveCapacity(static_cast<int>(length * scaleRate + 0.5));
191     for (int scaledIndex = 0; ; ++scaledIndex) {
192         int index = static_cast<int>(scaledIndex * inflateRate + 0.5);
193         if (index >= length)
194             break;
195         scaledValues.append(index);
196     }
197 }
198
199 template <MatchType type> int getScaledValue(const Vector<int>& scaledValues, int valueToMatch, int searchStart)
200 {
201     if (scaledValues.isEmpty())
202         return valueToMatch;
203
204     const int* dataStart = scaledValues.data();
205     const int* dataEnd = dataStart + scaledValues.size();
206     const int* matched = std::lower_bound(dataStart + searchStart, dataEnd, valueToMatch);
207     switch (type) {
208     case Exact:
209         return matched != dataEnd && *matched == valueToMatch ? matched - dataStart : -1;
210     case LowerBound:
211         return matched != dataEnd && *matched == valueToMatch ? matched - dataStart : matched - dataStart - 1;
212     case UpperBound:
213     default:
214         return matched != dataEnd ? matched - dataStart : -1;
215     }
216 }
217
218 }
219
220 void ImageDecoder::prepareScaleDataIfNecessary()
221 {
222     int width = size().width();
223     int height = size().height();
224     int numPixels = height * width;
225     if (m_maxNumPixels > 0 && numPixels > m_maxNumPixels) {
226         m_scaled = true;
227         double scale = sqrt(m_maxNumPixels / (double)numPixels);
228         fillScaledValues(m_scaledColumns, scale, width);
229         fillScaledValues(m_scaledRows, scale, height);
230     } else if (m_scaled) {
231         m_scaled = false;
232         m_scaledColumns.clear();
233         m_scaledRows.clear();
234     }
235 }
236
237 int ImageDecoder::upperBoundScaledX(int origX, int searchStart)
238 {
239     return getScaledValue<UpperBound>(m_scaledColumns, origX, searchStart);
240 }
241
242 int ImageDecoder::lowerBoundScaledX(int origX, int searchStart)
243 {
244     return getScaledValue<LowerBound>(m_scaledColumns, origX, searchStart);
245 }
246
247 int ImageDecoder::upperBoundScaledY(int origY, int searchStart)
248 {
249     return getScaledValue<UpperBound>(m_scaledRows, origY, searchStart);
250 }
251
252 int ImageDecoder::lowerBoundScaledY(int origY, int searchStart)
253 {
254     return getScaledValue<LowerBound>(m_scaledRows, origY, searchStart);
255 }
256
257 int ImageDecoder::scaledY(int origY, int searchStart)
258 {
259     return getScaledValue<Exact>(m_scaledRows, origY, searchStart);
260 }
261
262 }